{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network Variant Quantile Regression DQN (QR-DQN) implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement QR-DQN variant of DQN carrying on from `7.e-c51_dqn.ipynb`. First part of the notebook is all about the vanilla DQN and how we train. The QR-DQN variant is after these sections carried over from previous notebook.\n",
    "\n",
    "\n",
    "### RECAP\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^-$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla_{w_t} \\hat{q}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla_{w_t} \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/\n",
    "# !pip install -r requirements.txt\n",
    "# %cd ..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-16 15:35:47.005116: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-12-16 15:35:47.018366: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-12-16 15:35:47.158730: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-12-16 15:35:47.158828: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-12-16 15:35:47.159063: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-12-16 15:35:47.220097: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-12-16 15:35:47.222639: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-12-16 15:35:48.659012: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import math\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "import time\n",
    "from tqdm import trange\n",
    "import glob\n",
    "from collections import namedtuple\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole. Readers can try to run this on many other environments like Lunar Lander and others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "        \n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s,_ = env.reset(seed=seed)\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, termiated, truncated,_ = env.step(action)\n",
    "            reward += r\n",
    "            if termiated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_15340/1482465590.py:27: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:261.)\n",
      "  states = torch.tensor(states, device=device, dtype=torch.float32)\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon$-greedy) to sample from the environment and store the transitions `(s,a,r,s',done)` into a buffer. These samples are used multiple times in a learning making the process sample efficient.\n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Target network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with DQN\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation:\n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}_{w_t}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}_{w_t}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',a';w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network.\n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max\\limits_{a'} \\hat{q}(s'_i,a';w^-_t)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$\n",
    "w_{t+1} \\leftarrow w_t - \\alpha . \\nabla_{w_t}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\"\n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((predicted_qvalues_for_actions -\n",
    "                       target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set up Environment and Policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state,_ = env.reset(seed=seed)\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training agent function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state, _  = env.reset(seed=seed)\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state, _ = env.reset(seed=seed)\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean return per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████| 30001/30001 [02:05<00:00, 239.80it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 126.0\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = agent.get_action(obs).detach().cpu().numpy()\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                     "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/7_f/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantile Regression (QR-DQN)\n",
    "\n",
    "Similar to C51 approach of distributional RL, the QR-DQN approach also depended on using quantiles to predict the distribution of Q(s,a) instead of predicting an estimate of the average of Q(s,a). PLease refer to paper https://arxiv.org/pdf/1710.10044.pdf for more details. Both C51 and QR-DQN are variants of distributional RL and produced by scientists from DeepMind. \n",
    "\n",
    "The C51 approach modeled the distribution of $Q^{\\pi}(s,a)$ named $Z^{\\pi}(s,a)$ as a categorical distribution of probability over fixed points in the range of $V_{min}$ to $V_{max}$. The probability over these points was what was learnt by the network. Such an approached resulted in use of a projection step after bellman update to bring the new probabilities back to the fixed support points of `n_atoms` spread uniformly over $V_{min}$ to $V_{max}$. While the result worked there was a bit of disconnect with the theoretical basis on which the algorithm was derived.\n",
    "\n",
    "In contrast, in QR-DQN the approach was slightly different. The support points are still `N` but now the probabilities were fixed to 1/N with the location of these points something being learnt by network. In the words of authors....\n",
    "\n",
    ">We “transpose” the parametrization from C51: whereas the former uses N fixed locations for its approximation distribution and adjusts their probabilities, we assign fixed, uniform probabilities to N adjustable locations\n",
    "\n",
    "\n",
    "The loss used in this approach is that of quantile regression loss mixed with huber loss called **Quantile Huber loss** - equation 9 and 10 in the linked paper.\n",
    "\n",
    "Code cells below give an implementation of QR-DQN. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QRDQN(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, N=51, epsilon=0):\n",
    "\n",
    "        super(QRDQN, self).__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        self.N = N\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions*N)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        qvalues= qvalues.view(-1, self.n_actions, self.N)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.mean(-1).argmax(-1)\n",
    "        return best_actions\n",
    "        \n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions, N = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.mean(-1).argmax(-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_qr_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)   #(batch_size, state_dim)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)  #(batch_size,)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float) #(batch_size,)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float) #(batch_size, state_dim)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float) #(batch_size,)\n",
    "        \n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q_s = agent(states)  #(batch_size, n_actions, N)\n",
    "    batch_size, n_actions, N = q_s.shape\n",
    "    \n",
    "    tau = torch.FloatTensor([i/N for i in range(1,N+1)]).to(device) #(N,)\n",
    "    \n",
    "    # select q-values for chosen actions\n",
    "    q_s_a = q_s.gather(1, actions.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, N)) #(batch_size, 1, N)\n",
    "    # print(q_s_a.shape)\n",
    "    #q_s_a = q_s_a.expand(batch_size, N, N) #(batch_size, N, N)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        # compute q-values for all actions in next states\n",
    "        # use target network\n",
    "        q_s1 = target_network(next_states)  #(batch_size, n_actions, N)\n",
    "\n",
    "        # compute Qmax(next_states, actions) using predicted next q-values\n",
    "        s1_actions_max = torch.argmax(q_s1.mean(-1), dim=-1) #(batch_size,)\n",
    "        q_s1_amax = q_s1.gather(1, s1_actions_max.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, N)) #(batch_size, 1, N)\n",
    "        q_s1_amax = q_s1_amax.transpose(1,2) #(batch_size, N, 1)\n",
    "\n",
    "        rewards = rewards.unsqueeze(-1).unsqueeze(-1).expand(batch_size, N, 1) #(batch_size, N, 1)\n",
    "        done_flags = done_flags.unsqueeze(-1).unsqueeze(-1).expand(batch_size, N, 1) #(batch_size, N, 1)\n",
    "\n",
    "        targets = rewards + gamma * (1-done_flags) * q_s1_amax  # (batch_size, N, 1)\n",
    "        # print(targets.shape)\n",
    "        #targets = targets.expand(batch_size, N, 1) # (batch_size, N, N) \n",
    "        \n",
    "    td_errors = targets.detach() - q_s_a # (batch_size, N, N)\n",
    "        \n",
    "    k = 1.0 #kappa fixed at 1.0\n",
    "    \n",
    "    huber_loss = torch.where(td_errors.abs() <= k, 0.5*td_errors.pow(2), k*(td_errors.abs()-0.5*k)) # (batch_size, N, N)\n",
    "    quantile_loss = torch.abs(tau - (td_errors.detach() < 0).float()) * huber_loss # (batch_size, N, N)\n",
    "                            \n",
    "    # loss to minimize as per paper https://arxiv.org/pdf/1710.10044.pdf equation Algorithm 1 and eq 10\n",
    "    loss = quantile_loss.sum(-1).mean(-1).mean()\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_qr_dqn(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for i in range(n_games):\n",
    "        s, _ = env.reset(seed=seed+i)\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.mean(-1).argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent_qr_dqn(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state, _ = env.reset(seed=seed)\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state, _ = env.reset(seed=seed)\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            # target_network.load_state_dict(agent.state_dict())\n",
    "            for target_param, agent_param in zip(target_network.parameters(), agent.parameters()):\n",
    "                target_param.data.copy_(0.001*agent_param.data + (1.0-0.001)*target_param.data)\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate_qr_dqn(\n",
    "                make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean reward per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training parameters and network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 5 * 10**3\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 1\n",
    "eval_freq = 1000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "Env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = QRDQN(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = QRDQN(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.76250\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████▊| 4988/5001 [00:28<00:00, 206.86it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|                                                                                             | 0/1 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████▊| 4988/5001 [00:28<00:00, 206.86it/s]\u001b[A"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "t:   0%|                                                                                             | 0/1 [00:00<?, ?it/s, now=None]\u001b[A\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████▊| 4988/5001 [00:29<00:00, 206.86it/s]\u001b[A"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRgAAAHDCAYAAABPrnbiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAClWUlEQVR4nOzdd1hT5/sG8DsJIWyQLYqIOEBFRVREBLUynHVVf47WPVpxf6utHVar1rpRax0daluxra2jWgfgAvfeiLgnS2SvkJzfH0pqRBQVOAHuz3V5tTl5c84dHlpPnpz3PRJBEAQQERERERERERERvQGp2AGIiIiIiIiIiIio/GKDkYiIiIiIiIiIiN4YG4xERERERERERET0xthgJCIiIiIiIiIiojfGBiMRERERERERERG9MTYYiYiIiIiIiIiI6I2xwUhERERERERERERvjA1GIiIiIiIiIiIiemNsMBIREREREREREdEbY4ORiOgN1axZE4MHDxY7hijWrl0LiUSCW7dulelxJRIJpk+fXqbHJCIioteji39fDx48GCYmJsUaq4v539bdu3dhYGCAQ4cOiR2l1EgkEowZM0bsGG9k+vTpkEgkmsdKpRKOjo74/vvvRUxF9HrYYCTSYQVNHIlEgoMHDxZ6XhAEODo6QiKRoEuXLiIkJCIiIiJdVXAe+ao/+/fvx61bt7S2yeVyWFtbo1WrVvjss89w584dsd+OTgsNDUVISIjYMYr09ddfw8vLCz4+PmJHeSuHDx/G9OnTkZKSInaUUiWXyzFp0iTMnj0bOTk5YschKhY9sQMQ0asZGBggNDQUrVu31tp+4MAB3Lt3DwqFQqRkVFl98MEH6Nu3L3/3iIiIdNivv/6q9fiXX35BeHh4oe1ubm7Izs4GAPTr1w+dOnWCWq3G48ePceLECYSEhGDJkiX46aef0Ldv3zLLL5bs7Gzo6b3eR+XQ0FBcvHgREyZMKJ1QbyExMRHr1q3DunXrxI7y1g4fPowZM2Zg8ODBsLCwEDtOqRoyZAg+/fRThIaGYujQoWLHIXolNhiJyoFOnTph48aNWLp0qdbJTmhoKDw9PZGUlCRiujejVquRl5cHAwMDsaMUKTMzE8bGxmLHKJayziqTySCTycrseERERPT63n//fa3HR48eRXh4eKHtADTLnjRt2rTQ87dv30ZgYCAGDRoENzc3NG7cuNQy6wJdOT/Nz8+HWq2Gvr7+W+3nt99+g56eHrp27VpCyagsWFhYIDAwEGvXrmWDkcoFTpEmKgf69euHR48eITw8XLMtLy8Pf/31F/r37//C16jVaoSEhKBBgwYwMDCAnZ0dRo0ahcePH2uN27p1Kzp37gwHBwcoFAq4uLhg5syZUKlUWuPatm2Lhg0b4vLly2jXrh2MjIxQrVo1zJs3r1jvoWBNlPXr16NBgwZQKBTYtWsXAOD+/fsYOnQo7OzsoFAo0KBBA/z888+a1wqCAGtra0yaNEnr/VlYWEAmk2lNkZg7dy709PSQkZEBADh//jwGDx6MWrVqwcDAAPb29hg6dCgePXqkla9g3ZPLly+jf//+qFKliuaKUUEQMGvWLFSvXh1GRkZo164dLl26VKz3XTDdaMGCBVi8eDGcnJxgaGiINm3a4OLFi4XGX7lyBe+99x4sLS1hYGCAZs2a4Z9//tEaUzB1/sCBAxg9ejRsbW1RvXr1l+bIzc3FV199hdq1a0OhUMDR0RFTpkxBbm6u1rhn61SvXj0YGBjA09MTkZGRL8zw7BqMJ0+eRFBQEKytrWFoaAhnZ+dCJ0OZmZn43//+B0dHRygUCtSrVw8LFiyAIAiF8k6cOBE2NjYwNTXFu+++i3v37r3wvb3q94eIiIjejpOTE9auXYu8vLxin/s978yZM+jYsSPMzMxgYmKC9u3b4+jRo1pjlEolZsyYgTp16sDAwABWVlZo3bq11jlwXFwchgwZgurVq0OhUKBq1aro1q1bsdeFvn//Prp37w4TExPY2Njg448/LnTe+/wajOnp6ZgwYQJq1qwJhUIBW1tbBAQE4PTp0wCenCf/+++/uH37tmaKec2aNTWvT0hIwLBhw2BnZwcDAwM0bty40NWEz54zhoSEwMXFBQqFAsePH4exsTHGjx9f6L3cu3cPMpkMc+bMeel73rJlC7y8vAqtQRkbG4tevXrB3t4eBgYGqF69Ovr27YvU1FStn8WYMWOwceNG1K9fH4aGhvD29saFCxcAAKtWrULt2rVhYGCAtm3bvrAOGzduhKenJwwNDWFtbY33338f9+/fLzRu79698PX1hbGxMSwsLNCtWzdER0drnp8+fTomT54MAHB2dtb8rJ8/5pYtW9CwYUPNeWHBZ45nFef8cf/+/ZBIJPjzzz8xe/ZsVK9eHQYGBmjfvj2uXbtWaJ/Hjh1Dhw4dYG5uDiMjI7Rp0+aFa14ePHgQzZs3h4GBAVxcXLBq1apCYwoEBATg4MGDSE5OLnIMka7gFYxE5UDNmjXh7e2NDRs2oGPHjgCAnTt3IjU1FX379sXSpUsLvWbUqFFYu3YthgwZgnHjxuHmzZv47rvvcObMGRw6dAhyuRzAk0aRiYkJJk2aBBMTE+zduxfTpk1DWloa5s+fr7XPx48fo0OHDujZsyf69OmDv/76C5988gnc3d01uV5m7969+PPPPzFmzBhYW1ujZs2aiI+PR8uWLTUnLzY2Nti5cyeGDRuGtLQ0TJgwARKJBD4+PlpNrvPnzyM1NRVSqRSHDh1C586dAQBRUVHw8PDQnECFh4fjxo0bGDJkCOzt7XHp0iWsXr0aly5dwtGjR7UWUwaA3r17o06dOvjmm280Ta9p06Zh1qxZ6NSpEzp16oTTp08jMDAQeXl5xS0hfvnlF6SnpyM4OBg5OTlYsmQJ3nnnHVy4cAF2dnYAgEuXLsHHxwfVqlXDp59+CmNjY/z555/o3r07/v77b/To0UNrn6NHj4aNjQ2mTZuGzMzMIo+tVqvx7rvv4uDBgxg5ciTc3Nxw4cIFLF68GFevXsWWLVu0xh84cAB//PEHxo0bB4VCge+//x4dOnTA8ePH0bBhwxceIyEhAYGBgbCxscGnn34KCwsL3Lp1C5s2bdKMEQQB7777Lvbt24dhw4ahSZMm2L17NyZPnoz79+9j8eLFmrHDhw/Hb7/9hv79+6NVq1bYu3evpsbPKs7vDxEREb09b29vuLi4aDX7iuvSpUvw9fWFmZkZpkyZArlcjlWrVqFt27Y4cOAAvLy8ADxpIM2ZMwfDhw9HixYtkJaWhpMnT+L06dMICAgAAPTq1QuXLl3C2LFjUbNmTSQkJCA8PBx37tzRauq9iEqlQlBQELy8vLBgwQJERERg4cKFcHFxwUcffVTk6z788EP89ddfGDNmDOrXr49Hjx7h4MGDiI6ORtOmTfH5558jNTUV9+7d05zPFJyLZmdno23btrh27RrGjBkDZ2dnbNy4EYMHD0ZKSkqhxuGaNWuQk5ODkSNHQqFQoEaNGujRowf++OMPLFq0SGsGyYYNGyAIAgYMGFBkdqVSiRMnThR6f3l5eQgKCkJubi7Gjh0Le3t73L9/H9u3b0dKSgrMzc01Y6OiovDPP/8gODgYADBnzhx06dIFU6ZMwffff4/Ro0fj8ePHmDdvHoYOHYq9e/dqXlvweaR58+aYM2cO4uPjsWTJEhw6dAhnzpzRTHOOiIhAx44dUatWLUyfPh3Z2dlYtmwZfHx8cPr0adSsWRM9e/bE1atXsWHDBixevBjW1tYAABsbG83xDh48iE2bNmH06NEwNTXF0qVL0atXL9y5cwdWVlYAXv/88dtvv4VUKsXHH3+M1NRUzJs3DwMGDMCxY8c0Y/bu3YuOHTvC09MTX331FaRSKdasWYN33nkHUVFRaNGiBQDgwoULmnPm6dOnIz8/H1999ZXm88DzPD09IQgCDh8+zDX3SfcJRKSz1qxZIwAQTpw4IXz33XeCqampkJWVJQiCIPTu3Vto166dIAiC4OTkJHTu3FnzuqioKAGAsH79eq397dq1q9D2gv09a9SoUYKRkZGQk5Oj2damTRsBgPDLL79otuXm5gr29vZCr169XvleAAhSqVS4dOmS1vZhw4YJVatWFZKSkrS29+3bVzA3N9fkmz9/viCTyYS0tDRBEARh6dKlgpOTk9CiRQvhk08+EQRBEFQqlWBhYSFMnDjxpe9vw4YNAgAhMjJSs+2rr74SAAj9+vXTGpuQkCDo6+sLnTt3FtRqtWb7Z599JgAQBg0a9NL3ffPmTQGAYGhoKNy7d0+z/dixYwIArazt27cX3N3dtX7uarVaaNWqlVCnTh3NtoLfi9atWwv5+fkvPb4gCMKvv/4qSKVSISoqSmv7ypUrBQDCoUOHNNsACACEkydParbdvn1bMDAwEHr06FEow82bNwVBEITNmzdrfleLsmXLFgGAMGvWLK3t7733niCRSIRr164JgiAIZ8+eFQAIo0eP1hrXv39/AYDw1VdfabYV9/eHiIiIBCE4OFgo6iNgwTnL/Pnzi3x9t27dBABCamrqS4/z/N/X3bt3F/T19YXr169rtj148EAwNTUV/Pz8NNsaN26sdU77vMePH78yY1EGDRokABC+/vprre0eHh6Cp6fnS/Obm5sLwcHBL91/586dBScnp0LbQ0JCBADCb7/9ptmWl5cneHt7CyYmJppz24Kfv5mZmZCQkKC1j927dwsAhJ07d2ptb9SokdCmTZuX5rp27ZoAQFi2bJnW9jNnzggAhI0bN7709QAEhUKhOecTBEFYtWqVAECwt7fX5BcEQZg6darW+WFeXp5ga2srNGzYUMjOztaM2759uwBAmDZtmmZbkyZNBFtbW+HRo0eabefOnROkUqkwcOBAzbb58+drHeP5rPr6+ppzyoJ9PP/+i3v+uG/fPgGA4ObmJuTm5mrGLVmyRAAgXLhwQRCEJ+frderUEYKCgrQ+L2RlZQnOzs5CQECAZlv37t0FAwMD4fbt25ptly9fFmQy2Qv/23zw4IEAQJg7d26h54h0DadIE5UTffr0QXZ2NrZv34709HRs3769yOnRGzduhLm5OQICApCUlKT54+npCRMTE+zbt08z1tDQUPPv6enpSEpKgq+vL7KysnDlyhWt/ZqYmGityaOvr48WLVrgxo0bxXoPbdq0Qf369TWPBUHA33//ja5du0IQBK2sQUFBSE1N1Uw98fX1hUqlwuHDhwE8+SbV19cXvr6+iIqKAgBcvHgRKSkp8PX1feH7y8nJQVJSElq2bAkAmn0/68MPP9R6HBERgby8PIwdO1brasfXvTKue/fuqFatmuZxixYt4OXlhR07dgAAkpOTsXfvXvTp00dTh6SkJDx69AhBQUGIjY0tNJVkxIgRxVoHcePGjXBzc4Orq6vWz/idd94BAK3fB+DJFQqenp6axzVq1EC3bt2we/fuQlOIChR8+7x9+3YolcoXjtmxYwdkMhnGjRuntf1///sfBEHAzp07NeMAFBr3/M/8dX5/iIiI6O0VXJWXnp5e7NeoVCqEhYWhe/fuqFWrlmZ71apV0b9/fxw8eBBpaWkAnpxPXLp0CbGxsS/cl6GhIfT19bF///5Cy/4U1/Pner6+vq88l7WwsMCxY8fw4MGD1z7ejh07YG9vj379+mm2yeVyjBs3DhkZGThw4IDW+F69emldkQcA/v7+cHBwwPr16zXbLl68iPPnz79wPc1nFSwLVKVKFa3tBVco7t69G1lZWS/dR/v27bWuDi244rRXr14wNTUttL3g53ny5EkkJCRg9OjRWutadu7cGa6urvj3338BAA8fPsTZs2cxePBgWFpaasY1atQIAQEBmnPD4vD394eLi4vWPszMzDSZ3uT8cciQIVrrYBZ81ijY59mzZxEbG4v+/fvj0aNHmv1lZmaiffv2iIyMhFqthkqlwu7du9G9e3fUqFFDsz83NzcEBQW98P0U1K08rrlPlQ8bjETlhI2NDfz9/REaGopNmzZBpVLhvffee+HY2NhYpKamwtbWFjY2Nlp/MjIykJCQoBl76dIl9OjRA+bm5jAzM4ONjY3mROXZ9VcAoHr16oWmFFepUqXYJ3jOzs5ajxMTE5GSkoLVq1cXyjlkyBAA0GRt2rQpjIyMNM3Eggajn58fTp48iZycHM1zz95tOzk5GePHj4ednR0MDQ1hY2OjyfH8+3tRxtu3bwMA6tSpo7Xdxsam0Inayzz/egCoW7euZs2Ya9euQRAEfPnll4V+Fl999ZXWz6KorEWJjY3FpUuXCu23bt26L9xvUVmzsrKQmJj4wmO0adMGvXr1wowZM2BtbY1u3bphzZo1Wms83r59Gw4ODlonosCTk6qC5wv+KZVKtU4OAaBevXpaj1/n94eIiIjeXsEa18//Xf4yiYmJyMrKKvT3OPDkHECtVuPu3bsAgK+//hopKSmoW7cu3N3dMXnyZJw/f14zXqFQYO7cudi5cyfs7Ozg5+eHefPmIS4urlhZDAwMCjXvinMuO2/ePFy8eBGOjo5o0aIFpk+fXuwv2G/fvo06depAKtX+6P38+U+BF53fSaVSDBgwAFu2bNE0A9evXw8DAwP07t27WDmE59a7dnZ2xqRJk/Djjz/C2toaQUFBWL58+QvPj59thgH/NScdHR1fuL3g51nw3l5Ue1dXV61zv6LGubm5aZp1xfF8VkC7xm9y/vj8Pgs+AxTss6AhPmjQoEL7/PHHH5Gbm4vU1FQkJiYiOzv7hefaL3rvwH91e/4zGJEu4hqMROVI//79MWLECMTFxaFjx46aq8aep1arYWtrq/Ut57MKTqxSUlLQpk0bmJmZ4euvv4aLiwsMDAxw+vRpfPLJJ1Cr1VqvK+pquedPWIry7NWEBTmBJ3c4HDRo0Atf06hRIwBPvun18vJCZGQkrl27hri4OPj6+sLOzg5KpRLHjh1DVFQUXF1dtU4c+/Tpg8OHD2Py5Mlo0qQJTExMoFar0aFDh0Lv70UZy0pBlo8//rjIbzBr166t9bi4WdVqNdzd3bFo0aIXPv/8yeGbkEgk+Ouvv3D06FFs27YNu3fvxtChQ7Fw4UIcPXq00KLiJeF1fn+IiIjo7V28eBG2trYwMzMrlf37+fnh+vXr2Lp1K8LCwvDjjz9i8eLFWLlyJYYPHw7gyYyGrl27YsuWLdi9eze+/PJLzJkzB3v37oWHh8dL91+cmR8v0qdPH/j6+mLz5s0ICwvD/PnzMXfuXGzatKlY65C/jqLO7wYOHIj58+djy5Yt6NevH0JDQ9GlSxettRJfpGDdwRc1URcuXIjBgwdrft7jxo3DnDlzcPToUa0bCBb1c3vbzwal4VWZ3uT8sbj7nD9/Ppo0afLCsSYmJoVurlgcBXUrWG+SSJexwUhUjvTo0QOjRo3C0aNH8ccffxQ5zsXFBREREfDx8XlpE2r//v149OgRNm3aBD8/P832mzdvlmjuohTcIVilUsHf3/+V4319fTF37lxERETA2toarq6ukEgkaNCgAaKiohAVFaW1+PHjx4+xZ88ezJgxA9OmTdNsL2razYs4OTlpXvPstJ7ExMTXmprzomNevXpVM92kYN9yubxYP4vX4eLignPnzqF9+/bF+vazqKxGRkaFvvV/XsuWLdGyZUvMnj0boaGhGDBgAH7//XcMHz4cTk5OiIiIQHp6utaVDwVT8Qt+1k5OTlCr1bh+/brWt7kxMTFax3rd3x8iIiJ6c0eOHMH169dfOSX3eTY2NjAyMir09zjw5BxAKpVqfdlpaWmJIUOGYMiQIcjIyICfnx+mT5+uaTACT85t/ve//+F///sfYmNj0aRJEyxcuBC//fbbm7/BV6hatSpGjx6N0aNHIyEhAU2bNsXs2bM1DcaizrGcnJxw/vx5qNVqrasYnz//eZWGDRvCw8MD69evR/Xq1XHnzh0sW7bsla+rUaMGDA0Nizy/d3d3h7u7O7744gscPnwYPj4+WLlyJWbNmlWsXC9T8N5iYmI0S/MUiImJ0Tr3K9j2vCtXrsDa2hrGxsYA3v5KvtI4fyyYdWNmZvbSfdrY2MDQ0PCF59oveu/Af5/LCq54JdJlnCJNVI6YmJhgxYoVmD59Orp27VrkuD59+kClUmHmzJmFnsvPz0dKSgqA/76Ne/Zbxry8PHz//fclG7wIMpkMvXr1wt9//42LFy8Wev756bi+vr7Izc1FSEgIWrdurTnB8PX1xa+//ooHDx5orb/4ovcHACEhIcXO6O/vD7lcjmXLlmnt53X2AQBbtmzRWkPx+PHjOHbsmOak1NbWFm3btsWqVavw8OHDQq8vampycfTp0wf379/HDz/8UOi57OzsQlNOjhw5orX2zN27d7F161YEBgYW+Q3u48ePC/2cC77BLfi2tlOnTlCpVPjuu++0xi1evBgSiUTzsyj45/N3R3/+Z/66vz9ERET0Zm7fvo3BgwdDX18fkydPfq3XymQyBAYGYuvWrZqlYYAnd/INDQ1F69atNVdEFqwXWMDExAS1a9fWnEtkZWUhJydHa4yLiwtMTU3f6Oqw4lCpVIWmDdva2sLBwUHrmMbGxi+cXtypUyfExcVpXRyQn5+PZcuWwcTEBG3atCl2lg8++ABhYWEICQmBlZVVsa6elMvlaNasGU6ePKm1PS0tDfn5+Vrb3N3dIZVKS+xn2axZM9ja2mLlypVa+9y5cyeio6PRuXNnAE+at02aNMG6des0n1OAJ1fMhoWFoVOnTpptBY3GZ8e9jtI4f/T09ISLiwsWLFigWUbgRfuUyWQICgrCli1bcOfOHc3z0dHR2L179wv3ferUKUgkEnh7e792LqKyxisYicqZoi7lf1abNm0watQozJkzB2fPnkVgYCDkcjliY2OxceNGLFmyBO+99x5atWqFKlWqYNCgQRg3bhwkEgl+/fXXMp3W8O2332Lfvn3w8vLCiBEjUL9+fSQnJ+P06dOIiIhAcnKyZqy3tzf09PQQExODkSNHarb7+flhxYoVAKDVYDQzM9OszaNUKlGtWjWEhYW91hWaNjY2+PjjjzFnzhx06dIFnTp1wpkzZ7Bz587XmqpQu3ZttG7dGh999JGmSWplZYUpU6ZoxixfvhytW7eGu7s7RowYgVq1aiE+Ph5HjhzBvXv3cO7cuWIf71kffPAB/vzzT3z44YfYt28ffHx8oFKpcOXKFfz555/YvXs3mjVrphnfsGFDBAUFYdy4cVAoFJqG84wZM4o8xrp16/D999+jR48ecHFxQXp6On744QeYmZlpTgq7du2Kdu3a4fPPP8etW7fQuHFjhIWFYevWrZgwYYLm298mTZqgX79++P7775GamopWrVphz549uHbtWqHjvs7vDxEREb3a6dOn8dtvv0GtViMlJQUnTpzA33//rTlPfJPlR2bNmoXw8HC0bt0ao0ePhp6eHlatWoXc3FzMmzdPM65+/fpo27YtPD09YWlpiZMnT+Kvv/7CmDFjADyZUdG+fXv06dMH9evXh56eHjZv3oz4+Hj07du3xH4Gz0pPT0f16tXx3nvvoXHjxjAxMUFERAROnDiBhQsXasZ5enrijz/+wKRJk9C8eXOYmJiga9euGDlyJFatWoXBgwfj1KlTqFmzJv766y8cOnQIISEhr7WeZf/+/TFlyhRs3rwZH330EeRyebFe161bN3z++edIS0vTNHP37t2LMWPGoHfv3qhbty7y8/Px66+/ahpwJUEul2Pu3LkYMmQI2rRpg379+iE+Ph5LlixBzZo1MXHiRM3Y+fPno2PHjvD29sawYcOQnZ2NZcuWwdzcHNOnT9eMK7gR4eeff46+fftCLpeja9eumsZjcZT0+aNUKsWPP/6Ijh07okGDBhgyZAiqVauG+/fvY9++fTAzM8O2bdsAPDmf3rVrF3x9fTF69GhNs7lBgwZa640WCA8Ph4+Pj2aqO5FOK+O7VhPRa1izZo0AQDhx4sRLxzk5OQmdO3cutH316tWCp6enYGhoKJiamgru7u7ClClThAcPHmjGHDp0SGjZsqVgaGgoODg4CFOmTBF2794tABD27dunGdemTRuhQYMGhY4xaNAgwcnJ6ZXvBYAQHBz8wufi4+OF4OBgwdHRUZDL5YK9vb3Qvn17YfXq1YXGNm/eXAAgHDt2TLPt3r17AgDB0dGx0Ph79+4JPXr0ECwsLARzc3Ohd+/ewoMHDwQAwldffaUZ99VXXwkAhMTExEL7UKlUwowZM4SqVasKhoaGQtu2bYWLFy8KTk5OwqBBg176vm/evCkAEObPny8sXLhQcHR0FBQKheDr6yucO3eu0Pjr168LAwcOFOzt7QW5XC5Uq1ZN6NKli/DXX39pxhT39+JZeXl5wty5c4UGDRoICoVCqFKliuDp6SnMmDFDSE1N1YwrqNNvv/0m1KlTR1AoFIKHh4fW78KzGW7evCkIgiCcPn1a6Nevn1CjRg1BoVAItra2QpcuXYSTJ09qvS49PV2YOHGi4ODgIMjlcqFOnTrC/PnzBbVarTUuOztbGDdunGBlZSUYGxsLXbt2Fe7evVuoboLwer8/RERElVlwcLBQ1EfAgnOWgj96enqCpaWl4OXlJUydOlW4fft2sY/zor+vT58+LQQFBQkmJiaCkZGR0K5dO+Hw4cNaY2bNmiW0aNFCsLCwEAwNDQVXV1dh9uzZQl5eniAIgpCUlCQEBwcLrq6ugrGxsWBubi54eXkJf/755yszDRo0SDA2Ni60veAcsKj8ubm5wuTJk4XGjRsLpqamgrGxsdC4cWPh+++/13pNRkaG0L9/f8HCwkIAoHV+HB8fLwwZMkSwtrYW9PX1BXd3d2HNmjVar3/2nPFlOnXqJAAo9LN7mfj4eEFPT0/49ddfNdtu3LghDB06VHBxcREMDAwES0tLoV27dkJEREShn8Xz5/BFZd23b58AQNi4caPW9j/++EPw8PAQFAqFYGlpKQwYMEC4d+9eoZwRERGCj4+PYGhoKJiZmQldu3YVLl++XGjczJkzhWrVqglSqVTrfLSozxsvOmcvzvljUe+n4P0/X8MzZ84IPXv2FKysrASFQiE4OTkJffr0Efbs2aM17sCBA4Knp6egr68v1KpVS1i5cuULfw9TUlIEfX194ccffyz0noh0kUQQRFyBlYiogrt16xacnZ0xf/58fPzxx2LHeSWJRILg4OBC05iJiIiISHw9evTAhQsXXjiz42WGDRuGq1evIioqqpSSUUkLCQnBvHnzcP36ddFuREn0OrgGIxEREREREZGOe/jwIf7991988MEHr/3ar776CidOnMChQ4dKIRmVNKVSiUWLFuGLL75gc5HKDa7BSERERERERKSjbt68iUOHDuHHH3+EXC7HqFGjXnsfNWrUKHSDHNJdcrlc60YwROUBr2AkIiIiIiIi0lEHDhzABx98gJs3b2LdunWwt7cXOxIRUSFcg5GIiIiIiIiIiIjeGK9gJCIiIiIiIiIiojfGBiMRERERERERERG9sQp7kxe1Wo0HDx7A1NQUEolE7DhEREREr0UQBKSnp8PBwQFSKb8TLo94PkpERETlXXHPSStsg/HBgwdwdHQUOwYRERHRW7l79y6qV68udgx6AzwfJSIiooriVeekFbbBaGpqCuDJD8DMzKxUjqFUKhEWFobAwEDI5fJSOQa9GdZGN7Euuou10U2si+4qi9qkpaXB0dFRc05D5U9ZnI8C/H+FrmJddBdro5tYF93F2uimsqpLcc9JK2yDsWAaipmZWak2GI2MjGBmZsb/yHQMa6ObWBfdxdroJtZFd5VlbTi1tvwqi/NRgP+v0FWsi+5ibXQT66K7WBvdVNZ1edU5KRf0ISIiIiIiIiIiojfGBiMRERERERERERG9MTYYiYiIiIiIiIiI6I2xwUhERERERERERERvjA1GIiIiIiIiIiIiemNsMBIRERFRuRYZGYmuXbvCwcEBEokEW7Zseen4gwcPwsfHB1ZWVjA0NISrqysWL15caNzy5ctRs2ZNGBgYwMvLC8ePHy+ld0BERERUvrHBSERERETlWmZmJho3bozly5cXa7yxsTHGjBmDyMhIREdH44svvsAXX3yB1atXa8b88ccfmDRpEr766iucPn0ajRs3RlBQEBISEkrrbRARERGVW3piByAiIiIiehsdO3ZEx44diz3ew8MDHh4emsc1a9bEpk2bEBUVhZEjRwIAFi1ahBEjRmDIkCEAgJUrV+Lff//Fzz//jE8//bRk3wARERFROccGIxERERFVamfOnMHhw4cxa9YsAEBeXh5OnTqFqVOnasZIpVL4+/vjyJEjRe4nNzcXubm5msdpaWkAAKVSCaVSWUrpodl3aR6DXh/rortYG93Euugu1kY3lVVdirt/NhiJiIiIqFKqXr06EhMTkZ+fj+nTp2P48OEAgKSkJKhUKtjZ2WmNt7Ozw5UrV4rc35w5czBjxoxC28PCwmBkZFSy4V8gPDy81I9Br4910V2sjW5iXXQXa6ObSrsuWVlZxRr32g3GyMhIzJ8/H6dOncLDhw+xefNmdO/eXfO8IAj46quv8MMPPyAlJQU+Pj5YsWIF6tSpoxmTnJyMsWPHYtu2bZBKpejVqxeWLFkCExMTzZjz588jODgYJ06cgI2NDcaOHYspU6a8blwiIiIioheKiopCRkYGjh49ik8//RS1a9dGv3793nh/U6dOxaRJkzSP09LS4OjoiMDAQJiZmZVE5BdSKpUIDw9HQEAA5HJ5qR2HXg/rortYG93Euugu1kY3lVVdCmZkvMprNxgLFtEeOnQoevbsWej5efPmYenSpVi3bh2cnZ3x5ZdfIigoCJcvX4aBgQEAYMCAAXj48CHCw8OhVCoxZMgQjBw5EqGhoZrwgYGB8Pf3x8qVK3HhwgUMHToUFhYWmnVxiIiIiIjehrOzMwDA3d0d8fHxmD59Ovr16wdra2vIZDLEx8drjY+Pj4e9vX2R+1MoFFAoFIW2y+XyMvlAVlbHodfDuugu1kY3sS66i7XRTaVdl+Lu+7UbjC9bRFsQBISEhOCLL75At27dAAC//PIL7OzssGXLFvTt2xfR0dHYtWsXTpw4gWbNmgEAli1bhk6dOmHBggVwcHDA+vXrkZeXh59//hn6+vpo0KABzp49i0WLFrHBSEREREQlTq1Wa9ZP1NfXh6enJ/bs2aOZqaNWq7Fnzx6MGTNGxJREREREuklakju7efMm4uLi4O/vr9lmbm4OLy8vzYLYR44cgYWFhaa5CAD+/v6QSqU4duyYZoyfnx/09fU1Y4KCghATE4PHjx+XZGQiIiKi17bpzH0k5756HJWNjIwMnD17FmfPngXw5Jz07NmzuHPnDoAnU5cHDhyoGb98+XJs27YNsbGxiI2NxU8//YQFCxbg/fff14yZNGkSfvjhB6xbtw7R0dH46KOPkJmZqbmrtC7ZeOo+UvPETkFERESVWYne5CUuLg4AXrggdsFzcXFxsLW11Q6hpwdLS0utMQVTVp7dR8FzVapUKXRsMe7axzsp6S7WRjexLrqLtdFNrItuuvUoE59sugSZRIYuAdmwMHn1a94E6158J0+eRLt27TSPC9ZBHDRoENauXYuHDx9qmo3Ak6sRp06dips3b0JPTw8uLi6YO3cuRo0apRnzf//3f0hMTMS0adMQFxeHJk2aYNeuXYXOc8V2+HoSPttyCUYyGUxrPUQPzxpiRyIiIqJKqMLcRVrMu/bxTkq6i7XRTayL7mJtdBProlv2PZAAkMHFTMDhyH2ldpzi3rGPgLZt20IQhCKfX7t2rdbjsWPHYuzYsa/c75gxY3R+SrSNiQINHExx6UE6Jm68gIiYJMzq1hBVjPVf/WIiIiKiElKiDcaCRa/j4+NRtWpVzfb4+Hg0adJEMyYhIUHrdfn5+UhOTta83t7e/oWLaj97jOeJcdc+3klJd7E2uol10V2sjW5iXXTT+p9OAHiMhlWEUq1Nce/YR5VbHTtTbBzphUk/hiH8gQz/nn+I4zeTMbeXO95x1a2rLYmIiKjiKtEGo7OzM+zt7bFnzx5NQzEtLQ3Hjh3DRx99BADw9vZGSkoKTp06BU9PTwDA3r17oVar4eXlpRnz+eefQ6lUak7aw8PDUa9evRdOjwbEvWsf76Sku1gb3cS66C7WRjexLrojJSsPp+6kAAAaVhFKtTasORWXXCZFR0c1RnVphSmbLiI2IQND155En2bV8WWX+jA14O8SERERla7XvsnLyxbRlkgkmDBhAmbNmoV//vkHFy5cwMCBA+Hg4KC5A5+bmxs6dOiAESNG4Pjx4zh06BDGjBmDvn37wsHBAQDQv39/6OvrY9iwYbh06RL++OMPLFmyROsKRSIiIqKytj8mESq1gDq2xrAyEDsNkbaG1cywbWxrjPB1hkQC/HnyHjqEROHw9SSxoxEREVEF99pXML5qEe0pU6YgMzMTI0eOREpKClq3bo1du3bBwOC/s/D169djzJgxaN++PaRSKXr16oWlS5dqnjc3N0dYWBiCg4Ph6ekJa2trTJs2DSNHjnyb90pERET0ViKinyzZ0t7VFlCmipyGqDADuQyfd64Pfzc7fPzXOdxNzkb/H45hiE9NfNLBFQZymdgRiYiIqAJ67QbjqxbRlkgk+Prrr/H1118XOcbS0hKhoaEvPU6jRo0QFRX1uvGIiIiISkVevhoHriYCAN6pZ4OHF2NFTkRUNK9aVtg53g+z/43GhuN3sObQLRy4mohFfZqgiaOF2PGIiIiognntKdJEREREldGJW8lIz8mHtYk+GlU3FzsO0SuZKPQwp6c71gxpDltTBW4kZqLXisNYGBaDvHy12PGIiIioAmGDkYiIiKgYCqZHt6tnC5lUInIaouJrV88WYRP90K2JA1RqAcv2XkP35YdwJY53KiciIqKSwQYjERER0SsIgqBpMPrXtxM5DdHrszDSx5K+Hvh+QFNUMZLj8sM0vLvsEFbsvw6Vuujlj4iIiIiKgw1GIiIioleITcjA3eRs6OtJ4VvHWuw4RG+sk3tV7J7oB383W+Sp1Ji76wr6rDqCW0mZYkcjIiKicowNRiIiIqJXCL/85OpFHxcrGOm/9j3yiHSKrakBfhjYDPPeawQThR5O3X6Mjkui8OuRWy+9mSMRERFRUdhgJCIiInqFPU+nR7d34/RoqhgkEgn6NHPErgm+8K5lhWylCl9uvYSBPx/Hg5RsseMRERFROcMGIxEREdFLJGXk4szdFABAezdbccMQlbDqVYywfrgXpnetDwO5FFGxSQgKicTfp+7xakYiIiIqNjYYiYiIiF5i75UECALQsJoZqpobih2HqMRJpRIM9nHGjnG+aOJogfScfPxv4zmM+vUUkjJyxY5HRERE5QAbjEREREQvEfF0/cX2rpweTRVbLRsT/PWhNyYH1YNcJkHY5XgELY7ErotxYkcjIiIiHccGIxEREVERcpQqRMUmAQAC6rPBSBWfnkyK4Ha1sTW4NVztTfEoMw8f/nYKk/44i9RspdjxiIiISEexwUhERERUhCPXHyFbqYK9mQEaOJiJHYeozNR3MMPWMT4Y3dYFUgmw6cx9dAiJRFRsotjRiIiISAexwUhERERUhAjN3aNtIZFIRE5DVLYUejJM6eCKjR+2grO1MR6m5uCDn47jiy0XkJWXL3Y8IiIi0iFsMBIRERG9gCAI2BOdAADwd+P0aKq8PJ2q4N9xrTHI2wkA8NvRO+i4JAonbyWLnIyIiIh0BRuMRERERC9w6UEa4tJyYCiXwdvFSuw4RKIy0tfDjG4N8dswLziYG+D2oyz0XnUEc3ZGIzdfJXY8IiIiEhkbjEREREQvUDA92reONQzkMpHTEOmG1nWssWuiH3o1rQ5BAFYduIF3lx3CxfupYkcjIiIiEbHBSERERPQCBQ1Gf949mkiLmYEcC/s0xuoPPGFtoo+Y+HR0X34Iy/bEIl+lFjseERERiYANRiIiIqLnPEzNxsX7aZBIgHdcbcWOQ6STAhvYY/cEP3RoYI98tYCF4VfRa8VhXEvIEDsaERERlTE2GImIiIieU3BzFw9HC1ibKEROQ6S7rEwUWPF+U4T8XxOYGejh3L1UdF4ahZ8O3oRaLYgdj4iIiMoIG4xEREREz9nzdHp0e949muiVJBIJuntUw+6JfvCra4PcfDVmbr+M/j8exd3kLLHjERERURlgg5GIiIjoGVl5+Th0/REAIIDrLxIVW1VzQ6wb0hyzujeEkb4MR28ko+OSKPxx4g4EgVczEhERVWRsMBIRERE9Iyo2CXn5ajhaGqKOrYnYcYjKFYlEgvdbOmHneF80r1kFGbn5+OTvCxi27iQS0nLEjkdERESlhA1GIiIiomdEXH46PdrVDhKJROQ0ROWTk5Uxfh/pjc86uUJfJsXeKwkIDInEtnMPxI5GREREpYANRiIiIqKn1GoB+2Ke3OCF06OJ3o5MKsFIPxdsH9caDauZISVLibEbzmBM6Gk8zswTOx4RERGVIDYYiYiIiJ46ey8FSRl5MFXooXlNS7HjEFUIde1MsXm0D8a1rwOZVILt5x8iMCQS+64kiB2NiIiISggbjERERERPFUyPblPPBvp6PE0iKilymRSTAupi00et4GJjjMT0XAxZewKf/n0eGbn5YscjIiKit8QzZyIiIqKn9kQ/uaLK343To4lKQ2NHC/w7zhfDWjtDIgF+P3EXHUIiceTpnduJiIiofGKDkYiIiAjA3eQsxMSnQyaVoG09G7HjEFVYBnIZvuxSHxtGtET1Koa49zgb/X44iq+3XUaOUiV2PCIiInoDbDASERERAYiIfjI9uplTFVgY6Yuchqjia1nLCrsm+KFfC0cAwM+HbqLz0iicu5sibjAiIiJ6bWwwEhEREeG/BiPvHk1UdkwUepjTsxHWDG4OW1MFridmoueKw1gUFoO8fLXY8YiIiKiY2GAkIiKiSi8tR4ljN5IBAO25/iJRmWvnaouwiX54t7EDVGoBS/deQ4/vDyEmLl3saERERFQMbDASERFRpXcgJhH5agEuNsZwtjYWOw5RpWRhpI+l/TzwXX8PWBjJcelBGrouO4iVB65DpRbEjkdEREQvwQYjERERVXp7nk6P5t2jicTXpZEDwib44R1XW+Sp1Ph25xX836ojuP0oU+xoREREVAQ2GImIiKhSy1epsS8mEQCnRxPpClszA/w0qBnm9WoEE4UeTt5+jA4hUfj16G0IAq9mJCIi0jVsMBIREVGldvL2Y6RmK1HFSI6mNSzEjkNET0kkEvRp7oid433RspYlspUqfLnlIgb+fBwPU7PFjkdERETPYIORiIiIKrWC6dHt6tlCT8ZTIyJd42hphNDhLTGtS30o9KSIik1C4OJIbD5zj1czEhER6QieRRMREVGlFhGdAADwr8/p0US6SiqVYGhrZ/w7zheNHS2QnpOPiX+cw0e/ncajjFyx4xEREVV6bDASERFRpXU9MQM3kzIhl0ngW8da7DhE9Aq1bU3w94fe+DiwLvSkEuy6FIfAxZHYfSlO7GhERESVGhuMREREVGlFXH4yPbplLSuYGshFTkNExaEnk2LMO3WwdYwP6tmZ4lFmHkb9egqT/jyL1Gyl2PGIiIgqJTYYiYiIqNLaUzA9mnePJip3GjiY45+xPviwjQukEmDT6fvoEBKJg7FJYkcjIiKqdNhgJCIiokrpcWYeTt5OBgC0d7MVOQ0RvQmFngyfdnTFxg+94WRlhIepOXj/p2OYtvUisvLyxY5HRERUabDBSERERJXSvpgEqAXA1d4U1asYiR2HiN6Cp5Mldo73xQctnQAAvxy5jU5LonDq6ZcIREREVLrYYCQiIqJKKSL6yfqLAbx7NFGFYKSvh5ndG+LXYS1Q1dwAtx5loffKI/h25xXk5qvEjkdERFShscFIRERElU5uvgqRV5+s09ae6y8SVSi+dWywa4IfejatBrUArDxwHd2+O4RLD1LFjkZERFRhscFIRERElc6xG8nIyM2HjakCjaqZix2HiEqYuaEci/o0waoPPGFlrI8rcenovvwQvtsbi3yVWux4REREFQ4bjERERFTp7Hk6Pbq9qy2kUonIaYiotAQ1sMfuiX4IamAHpUrAgrCr6LXyCK4nZogdjYiIqEJhg5GIiIgqFUEQEBGdAIDTo4kqA2sTBVa+74lFfRrD1EAP5+6moNOSKKw5dBNqtSB2PCIiogqBDUYiIiKqVK7EpeN+SjYUelK0rm0tdhwiKgMSiQQ9m1ZH2EQ/+NaxRm6+GjO2XcaAH4/h3uMsseMRERGVe2wwEhERUaVSMD26dW1rGOrLRE5DRGWpqrkhfhnaAjO7N4ShXIYjNx6hQ0gU/jxxF4LAqxmJiIjeFBuMREREVKmEP50e7V+f06OJKiOJRIIPWjph53hfeDpVQUZuPqb8fR7D151EQnqO2PGIiIjKJTYYiYiIqNJISM/BubspAJ7c4IWIKq+a1sb4c5Q3Pu3oCn2ZFHuuJCBwcSS2n38gdjQiIqJyhw1GIiIiqjT2Pr16sXF1c9iaGYichojEJpNK8GEbF/wz1gf1q5ohJUuJMaFnMHbDGaRk5Ykdj4iIqNxgg5GIiIgqDd49umKKjIxE165d4eDgAIlEgi1btrx0/KZNmxAQEAAbGxuYmZnB29sbu3fv1hqjUqnw5ZdfwtnZGYaGhnBxccHMmTO5Tl8F5Wpvhi3BPhj3Tm3IpBJsO/cAgYsjsS8mQexoRERE5QIbjERERFQp5ChVOHgtEQDgzwZjhZKZmYnGjRtj+fLlxRofGRmJgIAA7NixA6dOnUK7du3QtWtXnDlzRjNm7ty5WLFiBb777jtER0dj7ty5mDdvHpYtW1Zab4NEpq8nxaTAevj7o1ZwsTFGQnouhqw5gambziMjN1/seERERDpNT+wARERERGXh0LUk5CjVcDA3gFtVU7HjUAnq2LEjOnbsWOzxISEhWo+/+eYbbN26Fdu2bYOHhwcA4PDhw+jWrRs6d+4MAKhZsyY2bNiA48ePl1hu0k1NHC3w7zhfzNsVg58P3cSG43dx8FoSFrzXGF61rMSOR0REpJPYYCQiIqJKISI6HsCTu0dLJBKR05AuUavVSE9Ph6WlpWZbq1atsHr1aly9ehV169bFuXPncPDgQSxatKjI/eTm5iI3N1fzOC0tDQCgVCqhVCpLLX/BvkvzGJWNDMDUDnXwTj0rfLLpIu4mZ6PvD0cx2NsJk/xrw0Aue+U+WBfdxdroJtZFd7E2uqms6lLc/bPBSERERBWeWi1gD9dfpCIsWLAAGRkZ6NOnj2bbp59+irS0NLi6ukImk0GlUmH27NkYMGBAkfuZM2cOZsyYUWh7WFgYjIyMSiX7s8LDw0v9GJXRuDrA5ttSHE2QYs3h29hx5hber61CDZPivZ510V2sjW5iXXQXa6ObSrsuWVlZxRrHBiMRERFVeBfupyIhPRfG+jK0rGX56hdQpREaGooZM2Zg69atsLW11Wz/888/sX79eoSGhqJBgwY4e/YsJkyYAAcHBwwaNOiF+5o6dSomTZqkeZyWlgZHR0cEBgbCzMys1N6DUqlEeHg4AgICIJfLS+04lVlPAPtiEvH5lkuIz8hDyCU5PvJzxui2tSCXvXhZe9ZFd7E2uol10V2sjW4qq7oUzMh4FTYYiYiIqMLb83R6tF9dGyj0Xj21kSqH33//HcOHD8fGjRvh7++v9dzkyZPx6aefom/fvgAAd3d33L59G3PmzCmywahQKKBQKAptl8vlZfKBrKyOU1kFNnRAc2drfLn1Iraff4jv9t/A/tgkLOrTBHXtil7XlXXRXayNbmJddBdro5tKuy7F3TfvIk1EREQVXgSnR9NzNmzYgCFDhmDDhg2aG7k8KysrC1Kp9qmyTCaDWq0uq4ikg6oY6+O7/k2xrJ8HLIzkuHg/DV2WHcTqyOtQqQWx4xEREYmGVzASERFRhXY/JRuXH6ZBKgHa1bMROw6VgoyMDFy7dk3z+ObNmzh79iwsLS1Ro0YNTJ06Fffv38cvv/wC4Mm06EGDBmHJkiXw8vJCXFwcAMDQ0BDm5uYAgK5du2L27NmoUaMGGjRogDNnzmDRokUYOnRo2b9B0jldGzvAy9kSn/x9HvtiEvHNjisIvxyPhb2boIZV6a+3SUREpGtK/ApGlUqFL7/8Es7OzjA0NISLiwtmzpwJQfjvGz1BEDBt2jRUrVoVhoaG8Pf3R2xsrNZ+kpOTMWDAAJiZmcHCwgLDhg1DRkZGScclIiKiCm7v0+nRTWtUgZVJ4emrVP6dPHkSHh4e8PDwAABMmjQJHh4emDZtGgDg4cOHuHPnjmb86tWrkZ+fj+DgYFStWlXzZ/z48Zoxy5Ytw3vvvYfRo0fDzc0NH3/8MUaNGoWZM2eW7ZsjnWVrZoCfBzfHtz3dYawvw4lbj9FhSSTWH7ut9dmHiIioMijxKxjnzp2LFStWYN26dWjQoAFOnjyJIUOGwNzcHOPGjQMAzJs3D0uXLsW6devg7OyML7/8EkFBQbh8+TIMDAwAAAMGDMDDhw8RHh4OpVKJIUOGYOTIkQgNDS3pyERERFSBhT+dHu1fn9OjK6q2bdu+tKGzdu1arcf79+9/5T5NTU0REhKCkJCQtwtHFZpEIkHfFjXgU9saH288h2M3k/H55ovYfSkes7u5iR2PiIiozJT4FYyHDx9Gt27d0LlzZ9SsWRPvvfceAgMDcfz4cQBPrl4MCQnBF198gW7duqFRo0b45Zdf8ODBA2zZsgUAEB0djV27duHHH3+El5cXWrdujWXLluH333/HgwcPSjoyERERVVAZufk4ev0RAMDfzfYVo4mI3oyjpRE2jGiJL7vUh0JPisiriei87DBOJkp4NSMREVUKJX4FY6tWrbB69WpcvXoVdevWxblz53Dw4EEsWrQIwJM1ceLi4rTu1Gdubg4vLy8cOXIEffv2xZEjR2BhYYFmzZppxvj7+0MqleLYsWPo0aNHoePm5uYiNzdX87jgNtpKpRJKpbKk36Zm38/+k3QHa6ObWBfdxdroJtbl7e2LjkeeSg0nSyPUsFCU2M+yLGrDuhOVL1KpBMNaO6NNXWv8789zOHcvFb9ekyHh93P4pmcjLtFAREQVWok3GD/99FOkpaXB1dUVMpkMKpUKs2fPxoABAwBAs4i2nZ32NCU7OzvNc3FxcbC11b7KQE9PD5aWlpoxz5szZw5mzJhRaHtYWBiMjEp3oeXw8PBS3T+9OdZGN7Euuou10U2sy5tbf00KQApnRQZ27txZ4vsvzdpkZWWV2r6JqPTUtjXF3x+1wrI9V7Fs3zXsvpyAU3ciMadnIwRwqQYiIqqgSrzB+Oeff2L9+vUIDQ1FgwYNcPbsWUyYMAEODg4YNGhQSR9OY+rUqZg0aZLmcVpaGhwdHREYGAgzM7NSOaZSqUR4eDgCAgIgl8tL5Rj0Zlgb3cS66C7WRjexLm9HpRYwfe5+AEoM79gCXs6WJbbvsqhNwWwMIip/9GRSjGnnAnliDLbGmyM2IRMjfjmJ9zyrY1rX+jAz4P/TiYioYinxBuPkyZPx6aefom/fvgAAd3d33L59G3PmzMGgQYNgb28PAIiPj0fVqlU1r4uPj0eTJk0AAPb29khISNDab35+PpKTkzWvf55CoYBCUXjagVwuL/UPZWVxDHozrI1uYl10F2ujm1iXN3PuVjIeZylhZqAHLxcbyGUlvvR0qdaGNScq/xxNgM09vbFs/w2sjryBv07dw+FrSZjfuzF8aluLHY+IiKjElPiZdlZWFqRS7d3KZDKo1WoAgLOzM+zt7bFnzx7N82lpaTh27Bi8vb0BAN7e3khJScGpU6c0Y/bu3Qu1Wg0vL6+SjkxEREQVUHh0PACgbT3bUmkuEhEVh0JPiqkd3fDnKG/UsDTCg9QcDPjxGL7aehHZeSqx4xEREZWIEj/b7tq1K2bPno1///0Xt27dwubNm7Fo0SLNjVkkEgkmTJiAWbNm4Z9//sGFCxcwcOBAODg4oHv37gAANzc3dOjQASNGjMDx48dx6NAhjBkzBn379oWDg0NJRyYiIqIKaE/0k9kQ/lzzjIh0QPOaltg53hfvt6wBAFh35DY6LY3CqduPRU5GRET09kp8ivSyZcvw5ZdfYvTo0UhISICDgwNGjRqFadOmacZMmTIFmZmZGDlyJFJSUtC6dWvs2rULBgYGmjHr16/HmDFj0L59e0ilUvTq1QtLly4t6bhERERUAd1KysS1hAzoSSVoU9dG7DhERAAAY4UeZnV3R2B9e0z56zxuJmWi98rD+LCNC8b714FCTyZ2RCIiojdS4g1GU1NThISEICQkpMgxEokEX3/9Nb7++usix1haWiI0NLSk4xEREVElEPF0enQLZ0uYG3ItQyLSLX51bbB7gh9mbLuETWfu4/v917H3SgIW9WmC+g6lc4NKIiKi0sQFiYiIiKjCKZge3d6N06OJSDeZG8mx6P+aYOX7TWFprI8rcenotvwglu+7hnyVWux4REREr4UNRiIiIqpQUrOUOH4rGQDg72Yrchoiopfr0LAqdk/wQ0B9OyhVAubvjkHvVUdwIzFD7GhERETFxgYjERERVSj7ryZApRZQx9YETlbGYschInolG1MFVn/giYW9G8NUoYczd1LQaWkU1h66CbVaEDseERHRK7HBSERERBVKBO8eTUTlkEQiQS/P6tg90Q+ta1sjR6nG9G2X8f5Px3A/JVvseERERC/FBiMRERFVGEqVGvtjnjYYOT2aiMohBwtD/DK0BWZ2awBDuQyHrz9Ch8WR2HjyLgSBVzMSEZFuYoORiIiIKowTN5ORnpMPK2N9NHGsInYcIqI3IpVK8IF3TewY74umNSyQnpuPyX+dx4hfTiEhPUfseERERIWwwUhEREQVRsH06HautpBJJSKnISJ6O87Wxtj4YSt80sEV+jIpIqLjEbQ4EjsuPBQ7GhERkRY2GImIiKhCEAQBEdHxAAB/N66/SEQVg0wqwUdtXfDPWB+4VTXD4ywlRq8/jfG/n0FqllLseERERADYYCQiIqIK4lpCBu4kZ0FfJoVvHWux4xARlShXezNsDfbBmHa1IZUAW88+QGDIAc26s0RERGJig5GIiIgqhILp0d4uVjBW6Imchoio5OnrSfFxUD38/VEr1LI2RnxaLgavOYHPNl9AZm6+2PGIiKgSY4ORiIiIKgTN9Oj6nB5NRBWbR40q+HecLwa3qgkACD12Bx2WROL4zWRxgxERUaXFBiMRERGVe48ycnH6zmMAQHtXW5HTEBGVPkN9Gaa/2wChI7xQzcIQd5Oz8X+rj2D2v5eRo1SJHY+IiCoZNhiJiIio3Nt7JQGCADRwMIODhaHYcYiIykwrF2vsmuCLPs2qQxCAH6Juouuyg7hwL1XsaEREVImwwUhERETl3p6n6y+2592jiagSMjWQY957jfHjwGawNlEgNiEDPb4/hJCIq1Cq1GLHIyKiSoANRiIiIirXcpQqRMYmAgAC2GAkokrMv74dwib6obN7VeSrBYRExKLn94cRG58udjQiIqrg2GAkIiKicu3ojUfIylPBzkyBhtXMxI5DRCQqS2N9fNffA0v6NoG5oRwX7qei87KD+CHyBlRqQex4RERUQbHBSEREROVawd2j27vZQSKRiJyGiEh8EokE3ZpUQ9hEP7StZ4O8fDVm74hGv9VHcedRltjxiIioAmKDkYiIiMotQRA06y/6u/Hu0UREz7IzM8Cawc0xp6c7jPVlOH4rGR2WRCL02B0IAq9mJCKiksMGIxEREZVblx6k4WFqDgzlMrRysRY7DhGRzpFIJOjXogZ2TfBDC2dLZOWp8NnmCxiy9gTi03LEjkdERBUEG4xERERUbhVcvdi6jjUM5DKR0xAR6S5HSyP8PqIlvujsBn09KfbHJCJwcSS2nr3PqxmJiOitscFIRERE5VbB+oucHk1E9GpSqQTDfWvh37Gt4V7NHKnZSoz//SyCQ08jOTNP7HhERFSOscFIRERE5VJ8Wg4u3E+FRAK842ondhwionKjjp0pNo1uhYn+daEnlWDHhTgELo5ExOV4saMREVE5xQYjERERlUsF06MbV7eAjalC5DREROWLXCbFeP862DzaB3VsTZCUkYvhv5zE5I3nkJ6jFDseERGVM2wwEhERUblUMD06oD6vXiQielPu1c2xbWxrjPSrBYkE2HjqHjqEROHwtSSxoxERUTnCBiMRERGVO1l5+Tj09MNve66/SET0VgzkMnzWyQ1/jPRGDUsj3E/JRv8fj2H6P5eQnacSOx4REZUDbDASERFRuXMwNgm5+WpUr2KIenamYschIqoQWjhbYud4XwzwqgEAWHv4FjovjcKZO49FTkZERLqODUYiIiIqdwrWX/R3s4NEIhE5DRFRxWGs0MPsHu5YN7QF7MwUuJGUiV4rDmP+7ivIy1eLHY+IiHQUG4xERERUrqjVAvZc+a/BSEREJa9NXRuETWiD7k0coBaA5fuuo9vyQ4h+mCZ2NCIi0kFsMBIREVG5cu5eCpIycmGq0EMLZ0ux4xARVVjmRnKE9PXA9wOaooqRHNEP0/Dudwfx/f5ryFfxakYiIvoPG4xERERUrhTcPdqvng309XgqQ0RU2jq5V0XYxDbwd7ODUiVg3q4Y9F51BDeTMsWORkREOoJn5URERFSu/Lf+Iu8eTURUVmxMFfhhoCcW9G4MU4UeztxJQcclkVh3+BbUakHseEREJDI2GImIiKjcuJuchStx6ZBKgLZ12WAkIipLEokE73lWx66JfvCpbYUcpRpf/XMJA38+jgcp2WLHIyIiEbHBSEREROXGnqfTo5vVtEQVY32R0xARVU7VLAzx61AvzHi3AQzkUhy8loSgxZH469Q9CAKvZiQiqozYYCQiIqJy47+7R/PqRSIiMUmlEgxqVRM7xvnCo4YF0nPz8fHGcxj56ykkpueKHY+IiMoYG4xERERULqTnKHH0xiMAgL+bnchpiIgIAGrZmGDjKG9MDqoHuUyC8MvxCAqJxM4LD8WORkREZYgNRiIiIioXIq8mQakSUMvaGLVsTMSOQ0RET+nJpAhuVxv/jGkNV3tTJGfm4aP1pzHh9zNIzVKKHY+IiMoAG4xERERULkQ8XX/Rvz6vXiQi0kVuVc3wz5jWCG7nAqkE2HL2AYJCInHgaqLY0YiIqJSxwUhEREQ6L1+lxr6YJ+svtnfl+otERLpKX0+KyUGu+OujVnC2NkZcWg4G/Xwcn2++gMzcfLHjERFRKWGDkYiIiHTeqduPkZKlhIWRHJ5OVcSOQ0REr9C0RhXsGOeLwa1qAgDWH7uDjkuicOJWsrjBiIioVLDBSERERDqv4O7R7erZQk/G0xciovLAUF+G6e82wPrhXnAwN8Cd5Cz0WXUEc3ZEI0epEjseERGVIJ6hExERkc6LuPx0/UXePZqIqNzxqW2NXRP90NuzOgQBWBV5A+9+dxAX76eKHY2IiEoIG4xERESk064nZuBGUibkMgn86lqLHYeIiN6AmYEc83s3xg8Dm8HaRB9X4zPQffkhLImIhVKlFjseERG9JTYYiYiISKfteXr36Ja1rGBqIBc5DRERvY2A+nYIm9gGndztka8WsDjiKnqtOIxrCeliRyMiorfABiMRERHptIho3j2aiKgisTTWx/L+TbGkbxOYGejh/L1UdFp6ED9G3YBaLYgdj4iI3gAbjERERKSzHmfm4dTtxwCA9lx/kYiowpBIJOjWpBrCJrZBm7o2yMtXY9a/0ej7w1HcTc4SOx4REb0mNhiJiIhIZ+2/mgCVWoCrvSkcLY3EjkNERCXM3twAa4c0xzc93GGkL8Pxm8noEBKJDcfvQBB4NSMRUXnBBiMRERHpLM30aDdOjyYiqqgkEgn6e9XArvF+aFHTEpl5KkzddAFD155AfFqO2PGIiKgY2GAkIiIinZSXr8aBmEQAgD+nR9NLREZGomvXrnBwcIBEIsGWLVteOn7Tpk0ICAiAjY0NzMzM4O3tjd27dxcad//+fbz//vuwsrKCoaEh3N3dcfLkyVJ6F0RUw8oIG0a2xOed3KCvJ8W+mEQELo7EP+ceiB2NiIhegQ1GIiIi0knHbyYjIzcf1iYKNK5uIXYc0mGZmZlo3Lgxli9fXqzxkZGRCAgIwI4dO3Dq1Cm0a9cOXbt2xZkzZzRjHj9+DB8fH8jlcuzcuROXL1/GwoULUaVKldJ6G0QEQCaVYIRfLWwf2xoNq5khNVuJcRvOIDj0NJIz88SOR0RERdATOwARERHRi0RExwN4cvdoqVQichrSZR07dkTHjh2LPT4kJETr8TfffIOtW7di27Zt8PDwAADMnTsXjo6OWLNmjWacs7NzieQlolera2eKzaN98N3ea/hu3zX8e/4hjt1Ixtxe7rzpFxGRDmKDkYiIiHSOIAj/NRi5/iKVMrVajfT0dFhaWmq2/fPPPwgKCkLv3r1x4MABVKtWDaNHj8aIESOK3E9ubi5yc3M1j9PS0gAASqUSSqWy1PIX7Ls0j0Gvj3UpGWPaOqNNHUtM/vsiridmYti6k3ivaTV81rEeTA3e7OMsa6ObWBfdxdroprKqS3H3zwYjERER6ZyY+HTce5wNhZ4UretYix2HKrgFCxYgIyMDffr00Wy7ceMGVqxYgUmTJuGzzz7DiRMnMG7cOOjr62PQoEEv3M+cOXMwY8aMQtvDwsJgZFT6d0EPDw8v9WPQ62NdSsaHzsC/elIceCjBX6fvY++le+jvokYd8ze/0zRro5tYF93F2uim0q5LVlZWscaxwUhEREQ6Z8/Tu0f71LaGkT5PV6j0hIaGYsaMGdi6dStsbf+7WlatVqNZs2b45ptvAAAeHh64ePEiVq5cWWSDcerUqZg0aZLmcVpaGhwdHREYGAgzM7NSew9KpRLh4eEICAiAXC4vtePQ62FdSl53AMdvJeOTTZdw73E2vrsswyDvGvg4oA4M5LJi74e10U2si+5ibXRTWdWlYEbGq/CMnYiIiHRO+OUn06N592gqTb///juGDx+OjRs3wt/fX+u5qlWron79+lrb3Nzc8Pfffxe5P4VCAYVCUWi7XC4vkw9kZXUcej2sS8nyqWOHXROsMPvfaGw4fgfrjtxB1LVHWNSnCZo4WrzWvlgb3cS66C7WRjeVdl2Ku2/eRZqIiIh0SkJ6Ds7dSwHA9Rep9GzYsAFDhgzBhg0b0Llz50LP+/j4ICYmRmvb1atX4eTkVFYRiagIJgo9zOnpjjVDmsPWVIEbiZnoteIwFobFIC9fLXY8IqJKiQ1GIiIi0in7riRAEAD3auawMzMQOw6VAxkZGTh79izOnj0LALh58ybOnj2LO3fuAHgydXngwIGa8aGhoRg4cCAWLlwILy8vxMXFIS4uDqmpqZoxEydOxNGjR/HNN9/g2rVrCA0NxerVqxEcHFym742Iitauni3CJvrh3cYOUKkFLNt7Dd2XH8KVuOJN5yMiopLDBiMRERHplIin6y9yejQV18mTJ+Hh4QEPDw8AwKRJk+Dh4YFp06YBAB4+fKhpNgLA6tWrkZ+fj+DgYFStWlXzZ/z48ZoxzZs3x+bNm7FhwwY0bNgQM2fOREhICAYMGFC2b46IXsrCSB9L+3lgef+mqGIkx+WHaXh32SGs2H8dKvWb3wCGiIheD9dgJCIiIp2Ro1ThYGwSAE6PpuJr27YtBKHoRsLatWu1Hu/fv79Y++3SpQu6dOnyFsmIqKx0blQVzZ2r4LNNFxARnYC5u64gIjoeC3s3Rk1rY7HjERFVeLyCkYiIiHTG4etJyFaqUNXcAA0cSu+uu0REVPHYmhrgh4HNMO+9RjBR6OHU7cfouCQKvx659dIvIYiI6O2xwUhEREQ6o2B6dHs3W0gkEpHTEBFReSORSNCnmSN2TfCFdy0rZCtV+HLrJQz8+TgepGSLHY+IqMIqlQbj/fv38f7778PKygqGhoZwd3fHyZMnNc8LgoBp06ahatWqMDQ0hL+/P2JjY7X2kZycjAEDBsDMzAwWFhYYNmwYMjIySiMuERER6QBBELAnOh4A118kIqK3U72KEdYP98JXXetDoSdFVGwSgkIi8fepe7yakYioFJR4g/Hx48fw8fGBXC7Hzp07cfnyZSxcuBBVqlTRjJk3bx6WLl2KlStX4tixYzA2NkZQUBBycnI0YwYMGIBLly4hPDwc27dvR2RkJEaOHFnScYmIiEhHXLyfhvi0XBjpy9CylpXYcYiIqJyTSiUY4uOMHeN90cTRAuk5+fjfxnMI3nAO6Uqx0xERVSwlfpOXuXPnwtHREWvWrNFsc3Z21vy7IAgICQnBF198gW7dugEAfvnlF9jZ2WHLli3o27cvoqOjsWvXLpw4cQLNmjUDACxbtgydOnXCggUL4ODgUNKxiYiISGThT69e9KtjAwO5TOQ0RERUUbjYmOCvD72xKvIGQiKuIjw6AUf0ZKhSJx6dG1cXOx4RUYVQ4g3Gf/75B0FBQejduzcOHDiAatWqYfTo0RgxYgQA4ObNm4iLi4O/v7/mNebm5vDy8sKRI0fQt29fHDlyBBYWFprmIgD4+/tDKpXi2LFj6NGjR6Hj5ubmIjc3V/M4LS0NAKBUKqFUls7XUwX7La3905tjbXQT66K7WBvdVNnqEnE5DgDQtq6Vzr/nsqiNrv8MiIjKEz2ZFMHtaqNdPVtM/OMMYuIzELzhHPZcScJX7zaAuaFc7IhEROVaiTcYb9y4gRUrVmDSpEn47LPPcOLECYwbNw76+voYNGgQ4uKefHiws9NeW8nOzk7zXFxcHGxtbbWD6unB0tJSM+Z5c+bMwYwZMwptDwsLg5GRUUm8tSKFh4eX6v7pzbE2uol10V2sjW6qDHV5nAtcfqgHCQSo7p7DjrhzYkcqltKsTVZWVqntm4iosqrvYIa/P2yJCT+EYe9DKTaduY8jNx5h3nuN4FvHRux4RETlVok3GNVqNZo1a4ZvvvkGAODh4YGLFy9i5cqVGDRoUEkfTmPq1KmYNGmS5nFaWhocHR0RGBgIMzOzUjmmUqlEeHg4AgICIJfzGy9dwtroJtZFd7E2uqky1WX98bvA6Wh41KiCPt1aiB3nlcqiNgWzMYiIqGQp9KTo6qTGiM4t8cmmi7j1KAsf/HQc77esgc86ucFIv8Q/JhMRVXgl/n/OqlWron79+lrb3Nzc8PfffwMA7O3tAQDx8fGoWrWqZkx8fDyaNGmiGZOQkKC1j/z8fCQnJ2te/zyFQgGFQlFou1wuL/UPZWVxDHozrI1uYl10F2ujmypDXfbFJAEAAurbl6v3Wpq1KU8/ByKi8qhpDQvsGO+LuTuvYN2R2/jt6B1ExSZhYe/GaFbTUux4RETlSonfRdrHxwcxMTFa265evQonJycAT274Ym9vjz179mieT0tLw7Fjx+Dt7Q0A8Pb2RkpKCk6dOqUZs3fvXqjVanh5eZV0ZCIiIhJRZm4+jlx/BADwd7N9xWgiIqKSY6SvhxndGuK3YV5wMDfA7UdZ6L3qCObsjEZuvkrseERE5UaJNxgnTpyIo0eP4ptvvsG1a9cQGhqK1atXIzg4GAAgkUgwYcIEzJo1C//88w8uXLiAgQMHwsHBAd27dwfw5IrHDh06YMSIETh+/DgOHTqEMWPGoG/fvryDNBERUQUTFZuEPJUaNSyNUNvWROw4RERUCbWuY41dE/3Qq2l1CAKw6sANvLvsEC7eTxU7GhFRuVDiDcbmzZtj8+bN2LBhAxo2bIiZM2ciJCQEAwYM0IyZMmUKxo4di5EjR6J58+bIyMjArl27YGBgoBmzfv16uLq6on379ujUqRNat26N1atXl3RcIiIiEllEdDwAwN/NDhKJROQ0RERUWZkZyLGwT2Os+sAT1ib6iIlPR/flh7BsTyzyVWqx4xER6bRSWb22S5cu6NKlS5HPSyQSfP311/j666+LHGNpaYnQ0NDSiEdEREQ6QqUWsO/Kk3WXOT2aiIh0QVADezRzqoLPN1/ErktxWBh+FRHR8VjYpwmvtCciKkKJX8FIREREVFxn7z7Go8w8mBroobkzF9QnIiLdYGWiwIr3myLk/5rAzEAP5+6lovPSKPx08CbUakHseEREOocNRiIiIhJNRPSTqxfb1rOFXMbTEiIi0h0SiQTdPaph90Q/+NW1QW6+GjO3X0b/H4/ibnKW2PGIiHQKz+SJiIhINBGXC9Zf5PRoIiLSTVXNDbFuSHPM6t4QhnIZjt5IRsclUfjjxB0IAq9mJCIC2GAkIiIikdx+lInYhAzIpBK0rcsGIxER6S6JRIL3Wzph1wRfNHOqgozcfHzy9wUMW3cSCWk5YscjIhIdG4xEREQkioLp0S1qWsLcSC5yGiIioldzsjLGH6O8MbWjK/RlUuy9koDAkEhsO/dA7GhERKJig5GIiIhEsSf6yfTo9pweTURE5YhMKsGoNi7YPq41GlYzQ0qWEmM3nMGY0NN4nJkndjwiIlGwwUhERERlLjVbieM3kwEAAfXtRE5DRET0+uramWLzaB+Ma18HMqkE288/RGBIJPZdSRA7GhFRmWODkYiIiMrcgauJyFcLqG1rAicrY7HjEBERvRG5TIpJAXWx6aNWcLExRmJ6LoasPYFP/z6PjNx8seMREZUZNhiJiIiozHF6NBERVSSNHS3w7zhfDGvtDIkE+P3EXXQIicSR64/EjkZEVCbYYCQiIqIypVSpNdPHAtw4PZqIiCoGA7kMX3apjw0jWqJ6FUPce5yNfj8cxdfbLiNHqRI7HhFRqWKDkYiIiMrUyVuPkZaTD0tjfXjUqCJ2HCIiohLVspYVdk3wQ78WjgCAnw/dROelUTh3N0XcYEREpYgNRiIiIipTEU+nR7erZwuZVCJyGiIiopJnotDDnJ6NsGZwc9iaKnA9MRM9VxzGorAY5OWrxY5HRFTi2GAkIiKiMiMIgqbB6M/1F4mIqIJr52qL3RP80LWxA1RqAUv3XkOP7w8hJi5d7GhERCWKDUYiIiIqM9cTM3D7URb0ZVL41rUROw4REVGpq2Ksj2X9PPBdfw9YGMlx6UEaui47iJUHrkOlFsSOR0RUIthgJCIiojITEf3k5i4tXaxgotATOQ0REVHZ6dLIAWET/PCOqy3yVGp8u/MK/m/VEdxKyhQ7GhHRW2ODkYiIiMpMxOUn06MDOD2aiIgqIVszA/w0qBnm9WoEE4UeTt5+jI5LovDr0dsQBF7NSETlFxuMREREVCYeZeTi9J3HAIB33OxETkNERCQOiUSCPs0dsXO8L1rWskS2UoUvt1zEwJ+P42FqttjxiIjeCBuMREREVCb2xSRCLQD1q5qhmoWh2HGIiIhE5WhphNDhLTGtS30o9KSIik1C4OJIbD5zj1czElG5wwYjERERlYk9vHs0ERGRFqlUgqGtnfHvOF80drRAek4+Jv5xDh/9dhqPMnLFjkdEVGxsMBIREVGpy81XIfJqIgCgPadHExERaalta4K/P/TGx4F1oSeVYNelOAQujsTuS3FiRyMiKhY2GImIiKjUHb2RjMw8FWxNFXCvZi52HCIiIp2jJ5NizDt1sCXYB/XsTPEoMw+jfj2FSX+eRWq2Uux4REQvxQYjERERlbqC6dHt3WwhlUpETkNERKS7GlYzxz9jffBhGxdIJcCm0/fRISQSB2OTxI5GRFQkNhiJiIioVAmCgIjLBesvcno0ERHRqyj0ZPi0oys2fugNJysjPEzNwfs/HcO0rReRlZcvdjwiokLYYCQiIqJSFf0wHQ9Sc2Agl8KntrXYcYiIiMoNTydL7Bzviw9aOgEAfjlyG52WROHU7WSRkxERaWODkYiIiEpVxNPp0a1r28BALhM5DRERUflipK+Hmd0b4tdhLVDV3AC3HmWh98oj+HbnFeTmq8SOR0QEgA1GIiIiKmUF6y/6u9mKnISIiKj88q1jg10T/NCzaTWoBWDlgevo9t0hXHqQKnY0IiI2GImIiKj0xKfl4Ny9Jx983mGDkYiI6K2YG8qxqE8TrHzfE1bG+rgSl47uyw/hu72xyFepxY5HRJUYG4xERERUavZeSQAANHa0gK2pgchpiIiIKoYODe2xe6IfghrYQakSsCDsKnqtPILriRliRyOiSooNRiIiIio1BXePDuDVi0RERCXK2kSBle97YlGfxjA10MO5uynotCQKPx+8CbVaEDseEVUybDASERFRqcjOU+HgtSQAQHs3O5HTEBERVTwSiQQ9m1bH7gl+8K1jjdx8Nb7efhkDfjyGe4+zxI5HRJUIG4xERERUKg5eS0JuvhrVLAzham8qdhwiIqIKy8HCEL8MbYGZ3RrAUC7DkRuP0CEkCn+euAtB4NWMRFT62GAkIiKiUvHs3aMlEonIaYiIiCo2iUSCD7xrYud4X3g6VUFGbj6m/H0ew9edREJ6jtjxiKiCY4ORiIiISpxaLWDP0xu8cHo0ERFR2alpbYw/R3nj046u0JdJsedKAgIXR2L7+QdiRyOiCowNRiIiIipx5++nIjE9FyYKPXjVshQ7DhERUaUik0rwYRsX/DPWB/WrmiElS4kxoWcwdsMZpGTliR2PiCogNhiJiIioxBVMj/araw2FnkzkNERERJWTq70ZtgT7YOw7tSGTSrDt3AMELo7EvpgEsaMRUQXDBiMRERGVuPDLBesvcno0ERGRmPT1pPhfYD38/VEr1LIxRkJ6LoasOYGpm84jIzdf7HhEVEGwwUhEREQl6t7jLFyJS4dUArSrZyt2HCIiIgLQxNECO8b5YqiPMwBgw/G76LgkEsduPBI5GRFVBGwwEhERUYnaE/1k2lUzJ0tUMdYXOQ0REREVMJDLMK1rfWwY0RLVLAxxNzkbfX84ipnbLyNHqRI7HhGVY2wwEhERUYmKeLr+Yns3Xr1IRESki7xdrLBrgi/+r5kjBAH46eBNdFl2EOfvpYgdjYjKKTYYiYiIqMSk5yhx9OlUK//6XH+RiIhIV5kayDH3vUb4eXAz2JgqcC0hAz2+P4xF4VehVKnFjkdE5QwbjERERFRiomKToFQJcLY2houNidhxiIiI6BXecbVD2AQ/dG5UFSq1gKV7YtHj+0O4Gp8udjQiKkfYYCQiIqISE6G5ezSnRxMREZUXVYz1sbx/Uyzr5wELIzku3k9Dl2UHsTryOlRqQex4RFQOsMFIREREJUKlFrAv5skNXtq7cXo0ERFRedO1sQPCJvihXT0b5OWr8c2OK+i7+ghuP8oUOxoR6Tg2GImIiKhEnL7zGI+zlDA3lKOZUxWx41AlEhkZia5du8LBwQESiQRbtmx56fhNmzYhICAANjY2MDMzg7e3N3bv3l3k+G+//RYSiQQTJkwo2eBERDrI1swAPw9ujm97usNYX4YTtx6j45Io/Hb0NgSBVzMS0YuxwUhEREQlomB6dLt6NtCT8RSDyk5mZiYaN26M5cuXF2t8ZGQkAgICsGPHDpw6dQrt2rVD165dcebMmUJjT5w4gVWrVqFRo0YlHZuISGdJJBL0bVEDuyb4wcvZEll5Knyx5SIGrTmBuNQcseMRkQ7SEzsAERERVQwR0U8ajJweTWWtY8eO6NixY7HHh4SEaD3+5ptvsHXrVmzbtg0eHh6a7RkZGRgwYAB++OEHzJo1q6TiEhGVG46WRtgwoiV+PnQT83bHIPJqIgIXH8DX3RqiW5MnV40TEQFsMBIREVEJuJmUieuJmdCTStCmno3YcYhei1qtRnp6OiwtLbW2BwcHo3PnzvD39y9WgzE3Nxe5ubmax2lpaQAApVIJpVJZsqGfUbDv0jwGvT7WRXexNq9vUEtH+NSqgk82XcT5+2mY8MdZ7LzwADPerQ8rY/0SOQbrortYG91UVnUp7v7ZYCQiIqK3tufp1YtetSxhZiAXOQ3R61mwYAEyMjLQp08fzbbff/8dp0+fxokTJ4q9nzlz5mDGjBmFtoeFhcHIyKhEsr5MeHh4qR+DXh/rortYm9c32BGIkEqw654Uuy8n4FBsPPrWUsPdsuTWZmRddBdro5tKuy5ZWVnFGscGIxEREb218KfrL/pzejSVM6GhoZgxYwa2bt0KW1tbAMDdu3cxfvx4hIeHw8DAoNj7mjp1KiZNmqR5nJaWBkdHRwQGBsLMzKzEsxdQKpUIDw9HQEAA5HI2+HUF66K7WJu30xXApQdpmPz3BcQmZOLHGBl6eDjgy071YPoWXzKyLrqLtdFNZVWXghkZr8IGIxEREb2VlKw8nLz9GAAbjFS+/P777xg+fDg2btwIf39/zfZTp04hISEBTZs21WxTqVSIjIzEd999h9zcXMhkskL7UygUUCgUhbbL5fIy+UBWVseh18O66C7W5s01cbLCtrG+WBx+FaujbmDzmQc4diMZ83s3hk9t67faN+uiu1gb3VTadSnuvnmLRyIiInor+2MSoVILqGdnCkfL0p8GSlQSNmzYgCFDhmDDhg3o3Lmz1nPt27fHhQsXcPbsWc2fZs2aYcCAATh79uwLm4tERJWNgVyGqZ3c8Ocob9SwNMKD1BwM+PEYvtp6Edl5KrHjEVEZ4xWMRERE9Fb+u3u0rchJqLLKyMjAtWvXNI9v3ryJs2fPwtLSEjVq1MDUqVNx//59/PLLLwCeTIseNGgQlixZAi8vL8TFxQEADA0NYW5uDlNTUzRs2FDrGMbGxrCysiq0nYiosmte0xI7x/tizs5o/Hb0DtYduY3I2CQs6N0Ynk5VxI5HRGWEVzASERHRG8vLV+NATCIAwL8+p0eTOE6ePAkPDw94eHgAACZNmgQPDw9MmzYNAPDw4UPcuXNHM3716tXIz89HcHAwqlatqvkzfvx4UfITEZV3xgo9zOrujl+GtoC9mQFuJmWi98rDmLfrCnLzeTUjUWXAKxiJiIjojZ24lYz03HxYm+ijSXULseNQJdW2bVsIQtF3MF27dq3W4/3797/2Md7kNURElY1fXRvsnuCH6dsuYfOZ+/h+/3XsvZKARX2aoL5D6d3siojExysYiYiI6I0VTI9+x9UWUqlE5DREREQkNnMjORb/XxOsfL8pLI31cSUuHd2WH8TyfdeQr1KLHY+ISgkbjERERPRGBEF4Zv1FTo8mIiKi/3RoWBW7J/ghoL4dlCoB83fHoPeqI7iRmCF2NCIqBWwwEhER0RuJTcjA3eRs6OtJ4VvHWuw4REREpGNsTBVY/YEnFvZuDFOFHs7cSUGnpVFYe+gm1Oqil7YgovKHDUYiIiJ6I+GXn1y96ONiBSN9LutMREREhUkkEvTyrI7dE/3QurY1cpRqTN92Ge//dAz3U7LFjkdEJYQNRiIiInojezg9moiIiIrJwcIQvwxtga+7NYCBXIrD1x+hw+JIbDx596U36iKi8qHUG4zffvstJBIJJkyYoNmWk5OD4OBgWFlZwcTEBL169UJ8fLzW6+7cuYPOnTvDyMgItra2mDx5MvLz80s7LhERERVDUkYuztxNAQC0d7MVNwwRERGVC1KpBAO9a2LneD80rWGB9Nx8TP7rPEb8cgqJ6blixyOit1CqDcYTJ05g1apVaNSokdb2iRMnYtu2bdi4cSMOHDiABw8eoGfPnprnVSoVOnfujLy8PBw+fBjr1q3D2rVrMW3atNKMS0RERMW090oCBAFoWM0MVc0NxY5DRERE5YiztTE2ftgKn3Rwhb5MiojoeHT+7jDOPpKIHY2I3lCpNRgzMjIwYMAA/PDDD6hSpYpme2pqKn766ScsWrQI77zzDjw9PbFmzRocPnwYR48eBQCEhYXh8uXL+O2339CkSRN07NgRM2fOxPLly5GXl1dakYmIiKiYIp6uv+jP6dFERET0BmRSCT5q64J/xvrAraoZHmcpseaqDJM2nkdKFj/3E5U3pdZgDA4ORufOneHv76+1/dSpU1AqlVrbXV1dUaNGDRw5cgQAcOTIEbi7u8PO7r8PLUFBQUhLS8OlS5dKKzIREREVQ45ShajYJABsMBIREdHbcbU3w9ZgH3zUxhkSCNh2Pg5BIZHYH5MgdjQieg2lcsvH33//HadPn8aJEycKPRcXFwd9fX1YWFhobbezs0NcXJxmzLPNxYLnC557kdzcXOTm/rdmQ1paGgBAqVRCqVS+8Xt5mYL9ltb+6c2xNrqJddFdrI1u0tW6RF1NRLZSBTszBeraGOpcvrJQFrWpjD9XIiKqnPT1pJjkXwcGj2Kx5aEZbj7KwuA1J9DfqwY+7+QGY0WptC6IqASV+H+ld+/exfjx4xEeHg4DA4OS3n2R5syZgxkzZhTaHhYWBiMjo1I9dnh4eKnun94ca6ObWBfdxdroJl2ry583pACkqG2YjZ07d4odR1SlWZusrKxS2zcREZEuqmkKbO3hjUV7rmPt4VsIPXYHUbGJWNi7CVo4W4odj4heosQbjKdOnUJCQgKaNm2q2aZSqRAZGYnvvvsOu3fvRl5eHlJSUrSuYoyPj4e9vT0AwN7eHsePH9fab8FdpgvGPG/q1KmYNGmS5nFaWhocHR0RGBgIMzOzknp7WpRKJcLDwxEQEAC5XF4qx6A3w9roJtZFd7E2ukkX6yIIAr5ZEAkgF0MCPdGmro3YkURRFrUpmI1BRERUmRjqyzD93QYIbGCHyRvP425yNv5v9REMb+2M/wXWg4FcJnZEInqBEm8wtm/fHhcuXNDaNmTIELi6uuKTTz6Bo6Mj5HI59uzZg169egEAYmJicOfOHXh7ewMAvL29MXv2bCQkJMDW1hbAkysEzMzMUL9+/RceV6FQQKFQFNoul8tL/UNZWRyD3gxro5tYF93F2ugmXarLxfupiE/LhZG+DK3r2kFeyU/yS7M2ulJzIiIiMbRyscauCb6Yuf0y/jx5Dz9E3cT+mEQs6tME7tXNxY5HRM8p8QajqakpGjZsqLXN2NgYVlZWmu3Dhg3DpEmTYGlpCTMzM4wdOxbe3t5o2bIlACAwMBD169fHBx98gHnz5iEuLg5ffPEFgoODX9hEJCIiorIREf1kRkHr2ta8goCIiIhKlamBHPPea4zA+vb4dNMFxCZkoMf3hzDmndoIblcbclmp3beWiF6TKP81Ll68GF26dEGvXr3g5+cHe3t7bNq0SfO8TCbD9u3bIZPJ4O3tjffffx8DBw7E119/LUZcIiIieqqgwehfn3ePJiIiorLhX98OYRP90Nm9KvLVAkIiYtHz+8OIjU8XOxoRPVUmt2Lav3+/1mMDAwMsX74cy5cvL/I1Tk5O2LFjRyknIyIiouJ6mJqNi/fTIJEA77jaih2HiIiIKhFLY318198DgefsMG3rJVy4n4rOyw5icmA9DG3tDJlUInZEokqN1xMTERFRseyJTgAAeDhawNqES5YQERFR2ZJIJOjWpBrCJvqhbT0b5OWrMXtHNPqtPoo7j7LEjkdUqbHBSERERMWy5+n06PZunB5NRERE4rEzM8Cawc0xp6c7jPVlOH4rGR2WRCL02B0IgiB2PKJKiQ1GIiIieqWsvHwcuv4IABDA9ReJiIhIZBKJBP1a1MDO8X5o4WyJrDwVPtt8AUPWnkB8Wo7Y8YgqHTYYiYiI6JWiYpOQl6+Go6Uh6tiaiB2HiIiICABQw8oIv49oiS86u0FfT4r9MYkIXByJrWfv82pGojLEBiMRERG9UsTlp3ePdrODRMJF1ImIiEh3SKUSDPethX/HtoZ7NXOkZisx/vezCA49jeTMPLHjEVUKbDASERHRS6nUAvZeeXKDF3+uv0hEREQ6qo6dKTaNboUJ/nWgJ5Vgx4U4BC6O1HxRSkSlhw1GIiIieqmzd1PwKDMPpgZ6aOFsKXYcIiIioiLJZVJM8K+LzaN9UMfWBEkZuRj+y0lM3ngO6TlKseMRVVhsMBIREdFLFdw9uk1dG8hlPHUgIiIi3ede3RzbxrbGSL9akEiAjafuoUNIFA5fSxI7GlGFxE8JRERE9FJ7ojk9moiIiMofA7kMn3Vywx8jvVHD0gj3U7LR/8djmP7PJWTnqcSOR1ShsMFIRERERbqbnIWY+HTIpBK0rWcjdhwiIiKi19bC2RI7x/tigFcNAMDaw7fQeWkUTt95LHIyooqDDUYiIiIqUsTT6dHNnKrAwkhf5DREREREb8ZYoYfZPdyxdkhz2JkpcCMpE++tOIz5u68gL18tdjyico8NRiIiIipSQYMxoD6nRxMREVH517aeLcImtEH3Jg5QC8DyfdfRbfkhRD9MEzsaUbnGBiMRERG9UFqOEsduJAMA2nP9RSIiIqogzI3kCOnrge8HNEUVIzmiH6bh3e8O4vv915Cv4tWMRG+CDUYiIiJ6oQMxichXC3CxMYaztbHYcYiIiIhKVCf3qgib2Ab+bnZQqgTM2xWD3quO4GZSptjRiModNhiJiIjohfY8nR7Nu0cTERFRRWVjqsAPAz0x/71GMFXo4cydFHRcEol1h29BrRbEjkdUbrDBSERERIXkq9TYF5MIAPDn+otERERUgUkkEvRu5ohdE/3QysUKOUo1vvrnEj74+RgepGSLHY+oXGCDkYiIiAo5efsxUrOVqGIkR9MaVcSOQ0RERFTqqlkY4rdhXpjxbgMYyKU4dO0RghZH4q9T9yAIvJqR6GXYYCQiIqJCIi4/mR7dztUWMqlE5DREREREZUMqlWBQq5rYMc4XHjUskJ6bj483nsPIX08hMT1X7HhEOosNRiIiIipkz5UEAFx/kYiIiCqnWjYm2DjKG5OD6kEukyD8cjyCQiKx88JDsaMR6SQ2GImIiEjL9cQM3EzKhL5MCr+6NmLHISIiIhKFnkyK4Ha1sTW4NVztTZGcmYeP1p/GhN/PIDVLKXY8Ip3CBiMRERFpKZge7VXLEiYKPZHTEBEREYmrvoMZto7xwei2LpBKgC1nHyAoJBIHriaKHY1IZ7DBSERERFr2RHN6NBEREdGzFHoyTOngir8+agVna2PEpeVg0M/H8fnmC8jMzRc7HpHo2GAkIiIijceZeTh5OxkA0N7NVuQ0RERERLqlaY0q2DHOF4Nb1QQArD92Bx2XROHErWRxgxGJjA1GIiIi0tgXkwC1ALjam6J6FSOx4xARERHpHEN9Gaa/2wDrh3vBwdwAd5Kz0GfVEXyzIxo5SpXY8YhEwQYjERERaUREP1l/MaA+p0cTERERvYxPbWvsmuiH9zyrQxCA1ZE38O53B3HxfqrY0YjKHBuMREREBADIzVch8moSAKA9118kIiIieiUzAzkW9G6MHwY2g7WJPq7GZ6D78kNYEhELpUotdjyiMsMGIxEREQEAjt1IRkZuPmxMFWhUzVzsOERERETlRkB9O4RNbINO7vbIVwtYHHEVvVYcxrWEdLGjEZUJNhiJiIgIALDn6fTo9q62kEolIqchIiIiKl8sjfWxvH9TLOnbBGYGejh/LxWdlh7Ej1E3oFYLYscjKlVsMBIREREEQUBEdAIAwJ/To4mIiIjeiEQiQbcm1RA2sQ386togL1+NWf9Go+8PR3E3OUvseESlhg1GIiIiwpW4dNxPyYZCTwqf2tZixyEiIiIq1+zNDbBuSHPM7tEQRvoyHL+ZjA4hkdhw/A4EgVczUsXDBiMREREh4vKT6dG+daxhqC8TOQ0RERFR+SeRSDDAywk7x/uiec0qyMxTYeqmCxi69gTi03LEjkdUothgJCIiIkRceTI9mnePJiIiIipZTlbG+H2kNz7v5AZ9PSn2xSQicHEk/jn3QOxoRCWGDUYiIqJKLiE9B+fupgB4coMXIiIiIipZMqkEI/xqYfvY1mhYzQyp2UqM23AGwaGnkZyZJ3Y8orfGBiMREVElt/fpzV0aVzeHrZmByGmIiIiIKq66dqbYPNoH49vXgUwqwb/nHyJwcST2RMeLHY3orbDBSEREVMkV3D2a06OJiIiISp9cJsXEgLrYPLoVatuaICkjF8PWncSUv84hPUcpdjyiN8IGIxERUSWWo1Th4LVEAIA/G4xEREREZaZRdQtsH9saw1s7QyIB/jx5Dx1ConD4epLY0YheGxuMREREldiha0nIUarhYG4At6qmYschIiIiqlQM5DJ80aU+fh/REo6Whrifko3+PxzDjG2XkKNUiR2PqNjYYCQiIqrEIp6u9+Nf3w4SiUTkNERERESVk1ctK+wc74d+LWoAANYcuoVOS6Nw5s5jkZMRFQ8bjERERJWUWi1gD9dfJCIiItIJJgo9zOnpjjVDmsPWVIEbiZnoteIwFuyOQV6+Wux4RC/FBiMREVEldeF+KhLSc2GsL0PLWpZixyEiIiIiAO3q2SJsoh/ebewAtQB8t+8aui8/hCtxaWJHIyoSG4xERESV1J6n06P96tpAoScTOQ3Rm4uMjETXrl3h4OAAiUSCLVu2vHT8pk2bEBAQABsbG5iZmcHb2xu7d+/WGjNnzhw0b94cpqamsLW1Rffu3RETE1OK74KIiOg/Fkb6WNrPA8v7N0UVIzkuP0zDu8sOYcX+61CpBbHjERXCBiMREVElFf50ejTvHk3lXWZmJho3bozly5cXa3xkZCQCAgKwY8cOnDp1Cu3atUPXrl1x5swZzZgDBw4gODgYR48eRXh4OJRKJQIDA5GZmVlab4OIiKiQzo2qYvdEP/i72SJPpcbcXVfQZ9UR3Eri30ekW/TEDkBERERl735KNqIfpkEqAdq52oodh+itdOzYER07diz2+JCQEK3H33zzDbZu3Ypt27bBw8MDALBr1y6tMWvXroWtrS1OnToFPz+/t85MRERUXLamBvhhYDNsPHUPX2+7jFO3H6PjkihM7eSK972cIJXyRn0kPjYYiYiIKqG9T6dHezpVgaWxvshpiMSlVquRnp4OS8ui1yJNTU0FgJeOyc3NRW5uruZxWtqTtbKUSiWUSmUJpS2sYN+leQx6fayL7mJtdBPr8mo9GtujhZM5Pt10EUdvPsa0rZew6+JDfNujIaqaG5TacVkb3VRWdSnu/tlgJCIiqoTCefdoIo0FCxYgIyMDffr0eeHzarUaEyZMgI+PDxo2bFjkfubMmYMZM2YU2h4WFgYjI6MSy1uU8PDwUj8GvT7WRXexNrqJdXm1/7MDHAQJtt2W4vD1ZAQtPoCezmo0txYgKcWLGVkb3VTadcnKyirWODYYiYiIKpmM3Hwcvf4IAODvxunRVLmFhoZixowZ2Lp1K2xtX/zfQ3BwMC5evIiDBw++dF9Tp07FpEmTNI/T0tLg6OiIwMBAmJmZlWjuZymVSoSHhyMgIAByubzUjkOvh3XRXayNbmJdXk8XAKMSMzFl00Wcu5eK9ddkSJDbYua7brAyUZTosVgb3VRWdSmYkfEqbDASERFVMlFXE5GnUqOmlRFcbEzEjkMkmt9//x3Dhw/Hxo0b4e/v/8IxY8aMwfbt2xEZGYnq1au/dH8KhQIKReEPdXK5vEw+kJXVcej1sC66i7XRTaxL8dVzsMDfH7XCqsgbCIm4ivDoBJy+k4LZPdzRoaF9iR+PtdFNpV2X4u6bd5EmIiKqZCKemR4tKc15NEQ6bMOGDRgyZAg2bNiAzp07F3peEASMGTMGmzdvxt69e+Hs7CxCSiIiopfTk0kR3K42tgT7wNXeFI8y8/Dhb6cw6Y+zSM3mmolUdthgJCIiqkRUagH7Yp40GP25/iJVEBkZGTh79izOnj0LALh58ybOnj2LO3fuAHgydXngwIGa8aGhoRg4cCAWLlwILy8vxMXFIS4uTnMjF+DJtOjffvsNoaGhMDU11YzJzs4u0/dGRERUHA0czLF1jA8+ausCqQTYdOY+OoREIio2UexoVEmwwUhERFSJnLnzGMmZeTAz0EOzmlXEjkNUIk6ePAkPDw94eHgAACZNmgQPDw9MmzYNAPDw4UNNsxEAVq9ejfz8fAQHB6Nq1aqaP+PHj9eMWbFiBVJTU9G2bVutMX/88UfZvjkiIqJiUujJ8EkHV2z80Bs1rYzwMDUHH/x0HF9suYCsvHyx41EFxzUYiYiIKpHw6HgAQDtXW8hl/J6RKoa2bdtCEIQin1+7dq3W4/37979yny/bHxERkS7zdLLEjvG+mLvzCtYduY3fjt5BVGwSFvZujGY1LcWORxUUP1kQERFVInueWX+RiIiIiComI309zOjWEL8N80JVcwPcfpSF3quOYM7OaOQoVWLHowqIDUYiIqJK4lZSJq4lZEBPKkGbujZixyEiIiKiUta6jjV2TfBDr6bVIQjAqgM38O53B3HxfuqrX0z0GthgJCIiqiQink6PbuFsCXNDuchpiIiIiKgsmBvKsbBPY6z6wBPWJvq4Gp+B7ssPYdmeWOSr1GLHowqCDUYiIqJKomB6NO8eTURERFT5BDWwx+4JfujQwB75agELw6+i14rDuJaQIXY0qgDYYCQiIqoEUrOUOH4rGQAbjERERESVlZWJAiveb4rF/9cYpgZ6OHcvFZ2XRuGngzehVvMGZ/Tm2GAkIiKqBPZfTYBKLaCOrQlqWBmJHYeIiIiIRCKRSNDDozrCJvrBt441cvPVmLn9Mvr9cBR3k7PEjkflFBuMRERElUBEwfTo+rx6kYiIiIiAquaG+GVoC8zq3hCGchmO3UxGh5BI/HHiDgSBVzPS62GDkYiIqIJTqtTYH1Ow/qKtyGmIiIiISFdIJBK839IJuyb4oplTFWTmqfDJ3xcwbN1JJKTliB2PyhE2GImIiCq4EzeTkZ6TDytjfTRxrCJ2HCIiIiLSMU5WxvhjlDemdnSFvkyKvVcSEBgSiW3nHogdjcqJEm8wzpkzB82bN4epqSlsbW3RvXt3xMTEaI3JyclBcHAwrKysYGJigl69eiE+Pl5rzJ07d9C5c2cYGRnB1tYWkydPRn5+fknHJSIiqvAKpke3c7WFTCoROQ0RERER6SKZVIJRbVywbWxrNHAwQ0qWEmM3nMGEP84jUyl2OtJ1Jd5gPHDgAIKDg3H06FGEh4dDqVQiMDAQmZmZmjETJ07Etm3bsHHjRhw4cAAPHjxAz549Nc+rVCp07twZeXl5OHz4MNatW4e1a9di2rRpJR2XiIioQhMEARHRT77E492jiYiIiOhV6tmbYvNoH4x7pzZkUgn+vRiHb8/JsP9qotjRSIfplfQOd+3apfV47dq1sLW1xalTp+Dn54fU1FT89NNPCA0NxTvvvAMAWLNmDdzc3HD06FG0bNkSYWFhuHz5MiIiImBnZ4cmTZpg5syZ+OSTTzB9+nTo6+uXdGwiIqIK6VpCBu4kZ0FfJoVvHWux4xARERFROaCvJ8WkwHpo72aHiX+cxY2kTIz49Qz6Nk/CF13qw0RR4u0kKudK/TciNTUVAGBpaQkAOHXqFJRKJfz9/TVjXF1dUaNGDRw5cgQtW7bEkSNH4O7uDju7/660CAoKwkcffYRLly7Bw8Oj0HFyc3ORm5ureZyWlob/b+/O46Oo7z+Ov3c3uxuOhCsk4QjIIbcExBIihwchiEjF+qv8PJCfimdioWlroa1GtBVaLWIVRVGr/fWHgAdaEYEYhQiiYCTKLaeikgRQyEWSze78/shBAkHJks1MNq/n47GPzcxOZt7Lh83OfvY7M5Lk8Xjk8QRmLG/legO1fviP2lgTdbEuamNN9VGXVVsPSZLiu7eVy25Q43rSEK8ZagUAAMwWG9Nab90zTPcuTNPabLsWbzqodXuO6NH/ilV8j3Zmx4OFBLTB6PP5NH36dA0fPlwDBgyQJGVnZ8vlcql169Y1lo2KilJ2dnbVMtWbi5WPVz5Wm9mzZ2vWrFmnzV+9erWaN29+rk/lR6WlpQV0/fAftbEm6mJd1MaazqUur291SLIpsixHK1asqL9QkBTY10xRUVHA1g0AAHC2Qp0OXXOeT1PHDdWMZdv0zQ8ndP3Cj3Xr8G6674reCnU6zI4ICwhogzEpKUlbt27VunXrArkZSdLMmTOVkpJSNZ2Xl6eYmBglJiYqPDw8INv0eDxKS0vTmDFj5HQ6A7IN+IfaWBN1sS5qY03nWpejhaU68PEaSdK9116mDq1C6zlh09UQr5nKozEAAACsIK5bW62cPkp/Xr5dizcd1Ivr92vtl7mae90gxca0NjseTBawBmNycrKWL1+ujIwMde7cuWp+dHS0SktLdezYsRqjGHNychQdHV21zMaNG2usr/Iq05XLnMrtdsvtdp823+l0BvzDckNsA/6hNtZEXayL2liTv3X5cE+2DEPq3zFcXSLCApAMgXzN8FoEAABW09IdojnXDlRi/yj9/vUt2nu4UL945iMlXdpDyZefL1dIvV9LGI1EvVfeMAwlJydr2bJlev/999WtW7cajw8ZMkROp1Pp6elV83bt2qWvv/5a8fHxkqT4+Hht2bJFubm5VcukpaUpPDxc/fr1q+/IAAAEpfQd5e+jo7l6NAAAAOrR5X2itHr6KE2I7Sivz9A/3t+ja55er13Z+WZHg0nqvcGYlJSkf//731q0aJHCwsKUnZ2t7OxsnThxQpLUqlUr3XbbbUpJSdEHH3ygzMxM3XLLLYqPj9ewYcMkSYmJierXr58mT56szz//XKtWrdKf/vQnJSUl1TpKEQAA1FTs8Spj92FJ0hgajAAAAKhnbVq49OT1g/XUDYPVurlT277L04Qn12nB2r3y+gyz46GB1XuD8ZlnntHx48d16aWXqkOHDlW3JUuWVC3z+OOP66qrrtK1116rUaNGKTo6Wm+88UbV4w6HQ8uXL5fD4VB8fLxuuukm3XzzzXrooYfqOy4AAEHp431HVVTqVVS4WwM6BeZcxAAAAMBVAztq9fRRurxPpEq9Ps15d6cmPbtBB44Umh0NDajez8FoGD/dpQ4NDdX8+fM1f/78My7TtWtXrnYJAICf3ttRfu7i0X2jZLPZTE4DAACAYBYZHqoXplykpZ8e1ENvb9enX/2gcU98qD+M76ub4rqwP9oEcPZNAACCjGEYVedfTOgbaXIaAAAANAU2m02TftZFK6eP0rDubXXC49X9b27VzS9u1KHjJ8yOhwCjwQgAQJDZ9l2eDh0vVjOnQxf3iDA7DgAAAJqQmLbNtWjqMD1wVT+5Q+z6cPcRJT6eoWWbvzmro17RONFgBAAgyFSOXhxxfoRCnQ6T0wAAAKCpsdttunVEN73zq5GKjWmt/OIy/XrJ57r735/paEGJ2fEQADQYAQAIMpXnX+Tq0QAAADBTz8iWev2ueP1mTC+F2G1auS1biY9naNW2bLOjoZ7RYAQAIIhkHy/Wlm+Py2aTLuvD+RcBAABgrhCHXfeOPl9vJg1X76gwHS0s1Z3/m6mUpVk6fsJjdjzUExqMAAAEkfSd5aMXB8W0Vvswt8lpAAAAgHIDOrXSf+4drrsu6SG7TXrjs291xbwMrdt9xOxoqAc0GAEACCInrx7N4dEAAACwFneIQzPG9dGrd8Wra7vmOnS8WDe98IkeeGurikrLzI6Hc0CDEQCAIFFUWqb1e8q/AabBCAAAAKsa0rWt3p02UpOHdZUk/WvDV7ryiQ+V+dX3JieDv2gwAgAQJNbtPqKSMp86t2mmXlEtzY4DAAAAnFFzV4genjhA/7p1qKLDQ3XgaJF+uWCD5ry7UyVlXrPjoY5oMAIAECSqHx5ts9lMTgMAAAD8tFG92mvVr0fpF4M7yWdIC9bu1dVPrde2746bHQ11QIMRAIAg4PMZSt/J+RcBAADQ+LRq5tTcSYO04KYhatfCpZ3Z+Zo4f72een+3yrw+s+PhLNBgBAAgCHz+zTEdKShRmDtEQ7u1NTsOAAAAUGdXDIjWql+P0tj+UfJ4DT22+ktdu2CD9h4uMDsafgINRgAAgsB7O3IkSaN6t5crhLd3AAAANE4RLd1acNMQzb0uVmGhIfr84DFd+cSHenHdfvl8htnxcAZ8AgEAIAicPP9ipMlJAAAAgHNjs9n0iws7a9X0URp5foRKynx6aPl23fj8J/rmhyKz46EWNBgBAGjkDn5fpJ3Z+XLYbbqsNw1GAAAABIeOrZvpX7cO1cNX91czp0Mb9h3VFfM+1NJNB2UYjGa0EhqMAAA0cukVh0cP6dpGrZu7TE4DAAAA1B+bzabJ8efp3WkjNaRrGxWUlOm+17/Q1Jc/VW5+sdnxUIEGIwAAjdx7FYdHj+Hq0QAAAAhS50W00NI74zVjXB+5HHal78xV4uMZWv7Fd2ZHg2gwAgDQqOUXe/TJ/qOSpNGcfxEAAABBzGG36a5Leug/9w5Xvw7hOlbkUfKizbr3lc06VlRqdrwmjQYjAACNWMaXR+TxGurevoW6t29pdhwAAAAg4PpEh+vNpOG69/Kecthtevvz75T4eIY+2JVrdrQmiwYjAACN2HsV519M4PBoAAAANCGuELt+k9hbr999sbq3b6Hc/BLd8s9NmvnGFyooKTM7XpNDgxEAgEaqzOur+pZ2dB8OjwYAAEDTMyimtVb8aqRuHd5NkvTKxoMa90SGPtl31ORkTQsNRgAAGqnMr37QsSKPWjd3akjXNmbHAQAAAEwR6nTogQn99Mrtw9SpdTMd/P6E/nvhx3p4+XYVe7xmx2sSaDACANBIpe8sH714We9IhTh4SwcAAEDTFt+jnVZOH6lJF8XIMKQX1u3XVU+u0xffHDM7WtDj0wgAAI3Ue9s5/yIAAABQXVioU3/9r4F6YcpFah/m1p7cAl3z9Eeam/alPF6f2fGCFg1GAAAaob2HC7TvSKGcDptG9YowOw4AAABgKaP7Rmn19FEaP7CDvD5D/0jfrWueXq8vc/LNjhaUaDACANAIpVdcPXpY93YKC3WanAYAAACwnjYtXJp/w4X6x/WD1aqZU1u/zdNVT67Tcxl75fUZZscLKjQYAQBohN7bwdWjAQAAgLPx89iOWv3rUbq0d3uVlvn0yIqd+u/nNuiro4VmRwsaNBgBAGhkfigs1acHvpdUfugHAAAAgB8XFR6qf/7PzzTnFxeohcuhTQd+0LgnPtS/P/5KhsFoxnNFgxEAgEZmzZe58hlSn+gwxbRtbnYcAAAAoFGw2Wz676FdtHL6KMV1a6uiUq/+9OZWTfnnJmUfLzY7XqNGgxEAgEam8vBorh4NAAAA1F1M2+Z65fZh+tP4vnKF2JXx5WElPr5Wb27+ltGMfqLBCABAI1Ja5tPaXYclSaP7cv5FAAAAwB92u01TR3bXil+N0MDOrZRXXKbpS7J0z/99pqMFJWbHa3RoMAIA0Ihs3P+9CkrKFNHSrdjOrc2OAwAAADRqPSPD9PrdFytlTC+F2G16d2u2xs7L0Opt2WZHa1RoMAIA0Ii8tyNHUvnVo+12m8lpAAAAgMbP6bDrV6PP15tJw9UrqqWOFJTqjv/N1G+Wfq68Yo/Z8RoFGowAADQShmGcbDByeDQAAABQrwZ0aqX/JI/QnaO6y2aTXv/sG13xeIbW7zlidjTLo8EIAEAjsSsnX9/8cELuELtGnB9hdhwAAAAg6IQ6HZp5ZV8tvTNeXdo213fHi3Xj858o9a2tOlHqNTueZdFgBACgkUivuHr08J4Rau4KMTkNAAAAELx+dl5bvTttpG4a1kWS9PKGr3TlPz5U5lc/mJzMmmgwAgDQSKRtLz88OqFvlMlJAGvJyMjQhAkT1LFjR9lsNr355ps/uvwbb7yhMWPGqH379goPD1d8fLxWrVp12nLz58/Xeeedp9DQUMXFxWnjxo0BegYAAMCKWrhD9OeJF+jlW4cqOjxU+48U6pcLPtJfV+5USRmjGaujwQgAQCOQm1+sz785JonzLwKnKiwsVGxsrObPn39Wy2dkZGjMmDFasWKFMjMzddlll2nChAnavHlz1TJLlixRSkqKUlNT9dlnnyk2NlZjx45Vbm5uoJ4GAACwqEt6tdeq6aN0zeBO8hnSM2v26uqn1mv7d3lmR7MMjq8CAKAR+GBnrgxDGti5laLCQ82OA1jKuHHjNG7cuLNeft68eTWmH3nkEb311lt6++23NXjwYEnS3Llzdfvtt+uWW26RJC1YsEDvvPOOXnzxRc2YMaPesgMAgMahVXOnHp80SGP7R+kPy7ZqZ3a+rp6/TtMTeunOUd0V4mjaY/hoMAIA0Ai8V3H+xdF9ODwaqG8+n0/5+flq27atJKm0tFSZmZmaOXNm1TJ2u10JCQnasGHDGddTUlKikpKSqum8vPJRDR6PRx6PJ0DpVbXuQG4DdUddrIvaWBN1sS5qU9Po3hF6Jzle97+1Xe/tPKxHV+1S2vZs/e0XA9QtokWD5Wioupzt+mkwAgBgccUerz7cfViSlNCPw6OB+vbYY4+poKBA1113nSTpyJEj8nq9ioqq2dCPiorSzp07z7ie2bNna9asWafNX716tZo3b16/oWuRlpYW8G2g7qiLdVEba6Iu1kVtarqqtRTVw6bXD9iVdfC4xj+5Tj/v4tOIaEN2W8PlCHRdioqKzmo5GowAAFjchn3fq9jjU8dWoerXIdzsOEBQWbRokWbNmqW33npLkZHn1sCfOXOmUlJSqqbz8vIUExOjxMREhYcH7rXr8XiUlpamMWPGyOl0Bmw7qBvqYl3Uxpqoi3VRmzMbL+mOYyc0c9k2fbTve71+wKHv7G01+5r+6tS6WUC33VB1qTwi46fQYAQAwOLe31U+enF03yjZbA34dSgQ5BYvXqypU6fq1VdfVUJCQtX8iIgIORwO5eTk1Fg+JydH0dHRZ1yf2+2W2+0+bb7T6WyQD2QNtR3UDXWxLmpjTdTFuqhN7bq2d+rfU4fp3598pUdW7NCGfd/rqqc26IEJ/fTLIZ0Dvv8e6Lqc7bqb9hkoAQCwOMOQPthZ2WDk8Gigvrzyyiu65ZZb9Morr2j8+PE1HnO5XBoyZIjS09Or5vl8PqWnpys+Pr6howIAAIuz2226Of48vTttlC7s0loFJWW677UvdPu/MpWbX2x2vAZBgxEAAAv7plDKyS9Rc5dDw7q3MzsOYEkFBQXKyspSVlaWJGn//v3KysrS119/Lan80OWbb765avlFixbp5ptv1t///nfFxcUpOztb2dnZOn78eNUyKSkpWrhwoV5++WXt2LFDd999twoLC6uuKg0AAHCqbhEt9OpdF+u+K3rL6bDpvR05Gvt4hlZsOWR2tICjwQgAgIVt+aH8rXrU+e0V6nSYnAawpk8//VSDBw/W4MGDJZU3BwcPHqwHHnhAknTo0KGqZqMkPffccyorK1NSUpI6dOhQdZs2bVrVMpMmTdJjjz2mBx54QIMGDVJWVpZWrlx52oVfAAAAqnPYbbrn0p76T/II9e0Qrh+KPLrn/z7TtMWbdayo1Ox4AcM5GAEAsLBtP5Sfs4XDo4Ezu/TSS2UYxhkff+mll2pMr1mz5qzWm5ycrOTk5HNIBgAAmqq+HcL1VtJw/SN9t55es0dvZX2nj/cd1V+vHahLewffvj0jGAEAsKhDx4v1TaFNNpt0eZ/g2wkBAAAAgpkrxK7fju2t1+++WN0jWignr0T/889N+sOyLSosKTM7Xr1iBCMAABZQ5vXpaGGpcvNKdLigWLl5JVq3u/ziLoNjWqtdy9OvTAsAAADA+gZ3aaN3fjVSf125Uy99dECLPvlaH+4+rL//cpCGdmtrdrx6QYMRAIAAOlHqVW5+sXLzS3Q4v0S5edV+rrgdzi/R0cISnekIz4S+7Rs2NAAAAIB61czl0IM/76/EflH63Wtf6OD3JzTpuQ2aOqKbfpPYu9Gfb50GIwAAdWQYho4VeSoahMUnm4V5JTpcUN5ErJxXUIdDHxx2myJautQ+zK3IsFBFtHCq6PDXumlolwA+GwAAAAAN5eKeEXp3+kg9/PZ2vZr5jRZ+uF8f7DqsudfFamDn1mbH8xsNRgAAKni8Ph0pKG8UnhxlWHPE4eG8Yh0uKJHHe+YLSpyqmdOhyHC32rd0KzK8vHnYPsxd0Ug8Od22hUsOu+1kHo9HK1Z8pWauxv1tJgAAAICTwkOdevSXsRrbP1oz3tiiPbkFuubpj5R8WU8lX95TTkfju2QKDUYAQNArKCk7w+HJ5SMNK6e/Lyyt03rbNHdWNQcjw9xqX9VEDK1oHJY3EVu6Q2Sz2X56hQAAAACajIR+UVrdtY3uf3Or3tlySE+k79b7O3M197pYnR8VZna8OqHBCABolHw+Q98XlVY7PLm44vDkkmpNw/KGYlGp96zXG2K3nWwYhrnVPiy06ufIsJPNw4iWbrlCGt83iwAAAACso20Ll566YbASP4/SA29t05Zvj2v8k+v0u8TeunVEtxpHOFkZDUYAgKWUlHl1pKC0arRh5YjDw/nF1c5xWKIjBSUq8539YcotXA5FhoeqfcvykYbVD00ubxyWjz5s09wleyN5EwcAAADQ+NlsNl09qJOGdW+n+177Qmu/PKy/rNihtO05euyXserSrrnZEX8SDUYAQMAZhqH8krKq0YWnHppc/UIpx4o8dVp3uxauauczDK04x2G16YqfW7h5ywMAAABgXVHhoXrplp/plY0H9ed3tmvjge91xRMZ+uP4vrphaBdLn3aJT1sAAL95fYaOFp68evLhvFOuqlztUOVij++s1+ty2KuahqdeCKVytGFkWKjatXQ1yhMgAwAAAEBtbDabbojrohE9I/Tb1z7Xxv3f64/Ltmr1thz99dqBim4VanbEWtFgBACcptjjPXnV5IrzGFYffVjZODxSUKI6HKWsMHdI1eHJlec2jKxl9GGrZk5LfzsHAAAAAIHUpV1zLb59mF5cv19/W7VLa788rLHzMvTQ1f3189iOZsc7DQ1GADhHhmHIZ0hlPp98vpr3XsOQ12eozGvIZxgq8xny+crvvZU3o9rPp9zKfLX9nk9enyrua1+malnDkNf7I9uo+D1PmVf7v7Hrid3rdaSgRHnFZWf9/G02qV2LmucxrBxheOrow2YuRwArAQAAAADBw263aerI7rqkV3ulLP1cW749rmmLs7RqW7ZSx/cxO14NNBjPwVufH9LSPXZlLNsqh90um2yqHHBTfl8+bauYrvG4VDU6p/pjleN1bLbyxytWU/vj1edVLFs5/+QyJ9elH3u8RnZbtYwns566rdpyVK3/lOd5MkfNbenUx2t5njX/HWuuq+JR6ZTHvV6vdh2zqdXeowpx8N/cKsq8Zdp5zKYWXx6Wze6o2RAzyptwP9YIq9F0q63ZdoZlKtdd2YT7sXWfvv6faAJWzA8OdkmFVVOuEPvpIwwrm4jVptu2cCmEw5QBAAAAICDOjwrTG/dcrPkf7NFT7+/Rii3Z2rj/e13TyaYrzQ5XwdKdl/nz5+vRRx9Vdna2YmNj9eSTT2ro0KFmx6qSdfCYNh62a+Ph78yOglo59PSOTLND4DQOacdms0M0GJtNCrHbZLfZyu/t5fcOu10OuxRit8teeW+rnD5lWZtNDvvpt7NZxmGzyeEov69t+w67XQ6bJMOnvTu3aczIoerYpoXah4UqPDSEw5QBAAAAwAKcDrumJ/TS6D5RSlmapd25BVq4y6FOGw/qf4Z3NzuedRuMS5YsUUpKihYsWKC4uDjNmzdPY8eO1a5duxQZGWl2PEnS6D6ROn7ogHr37iOb/eToHcMwZBiSIVXcn5yWUT7SqbbHKqdVMRjK+JF11djWGdZVuSLDqMO2qh47OX1yGeOM66qxrTOs62TmM6/rtG3Vsq4z/htWX94wlJefr/CwMBokFlJZlzatwuV0VGuk2WwKcZxswtVskpU3wKo3xE5fpvYGW23rPtlgO9MyJxt+Jxtwp6/3xxp51efZ7Y3j/5/H49GKo1sV372dnE6n2XEAAAAAALW4oHMrvX3vCD26code3XhAV/SPMjuSJAs3GOfOnavbb79dt9xyiyRpwYIFeuedd/Tiiy9qxowZJqcrN6JnO+V9aejKUd34QG4xHo9HK1as0JVXXkxtLORkXeKpCwAAAAAAfgh1OjTjit46v3Sv2rVwmR1HkkUbjKWlpcrMzNTMmTOr5tntdiUkJGjDhg21/k5JSYlKSkqqpvPy8iSVNzQ8Hk9AclauN1Drh/+ojTVRF+uiNtZEXayrIWpD3QEAAPBjmlmoq2ehKCcdOXJEXq9XUVE1h3lGRUVp586dtf7O7NmzNWvWrNPmr169Ws2bNw9IzkppaWkBXT/8R22sibpYF7WxJupiXYGsTVFRUcDWDQAAANQnSzYY/TFz5kylpKRUTefl5SkmJkaJiYkKDw8PyDY9Ho/S0tI0ZswYDve0GGpjTdTFuqiNNVEX62qI2lQejQEAAABYnSUbjBEREXI4HMrJyakxPycnR9HR0bX+jtvtltvtPm2+0+kM+IeyhtgG/ENtrIm6WBe1sSbqYl2BrA01BwAAQGNh/+lFGp7L5dKQIUOUnp5eNc/n8yk9PV3x8fEmJgMAAAAAAABQnSVHMEpSSkqKpkyZoosuukhDhw7VvHnzVFhYWHVVaQAAAAAAAADms2yDcdKkSTp8+LAeeOABZWdna9CgQVq5cuVpF34BAAAAAAAAYB7LNhglKTk5WcnJyWbHAAAAAAAAAHAGljwHIwAAAAAAAIDGgQYjAAAAAAAAAL/RYAQAAAAAAADgNxqMAAAAAAAAAPxGgxEAAAAAAACA32gwAgAAAAAAAPBbiNkBAsUwDElSXl5ewLbh8XhUVFSkvLw8OZ3OgG0HdUdtrIm6WBe1sSbqYl0NUZvKfZjKfRo0Pg2xPyrxt8KqqIt1URtroi7WRW2sqaHqcrb7pEHbYMzPz5ckxcTEmJwEAADAf/n5+WrVqpXZMeAH9kcBAECw+Kl9UpsRpF+L+3w+fffddwoLC5PNZgvINvLy8hQTE6ODBw8qPDw8INuAf6iNNVEX66I21kRdrKshamMYhvLz89WxY0fZ7ZzVpjFqiP1Rib8VVkVdrIvaWBN1sS5qY00NVZez3ScN2hGMdrtdnTt3bpBthYeH8yKzKGpjTdTFuqiNNVEX6wp0bRi52Lg15P6oxN8Kq6Iu1kVtrIm6WBe1saaGqMvZ7JPydTgAAAAAAAAAv9FgBAAAAAAAAOA3GoznwO12KzU1VW632+woOAW1sSbqYl3Uxpqoi3VRG1gJ/x+tibpYF7WxJupiXdTGmqxWl6C9yAsAAAAAAACAwGMEIwAAAAAAAAC/0WAEAAAAAAAA4DcajAAAAAAAAAD8RoMRAAAAAAAAgN9oMJ6D+fPn67zzzlNoaKji4uK0ceNGsyM1eRkZGZowYYI6duwom82mN9980+xIkDR79mz97Gc/U1hYmCIjIzVx4kTt2rXL7FiQ9Mwzz2jgwIEKDw9XeHi44uPj9e6775odC6eYM2eObDabpk+fbnaUJu/BBx+UzWarcevTp4/ZsdAE1HW/89VXX1WfPn0UGhqqCy64QCtWrGigpE1LXeqycOFCjRw5Um3atFGbNm2UkJDA54cA8vez2uLFi2Wz2TRx4sTABmyi6lqXY8eOKSkpSR06dJDb7VavXr34exYgda3NvHnz1Lt3bzVr1kwxMTH69a9/reLi4gZK2zT4099Ys2aNLrzwQrndbvXs2VMvvfRSwHNWosHopyVLliglJUWpqan67LPPFBsbq7Fjxyo3N9fsaE1aYWGhYmNjNX/+fLOjoJq1a9cqKSlJH3/8sdLS0uTxeJSYmKjCwkKzozV5nTt31pw5c5SZmalPP/1Ul19+ua6++mpt27bN7GiosGnTJj377LMaOHCg2VFQoX///jp06FDVbd26dWZHQpCr637nRx99pOuvv1633XabNm/erIkTJ2rixInaunVrAycPbnWty5o1a3T99dfrgw8+0IYNGxQTE6PExER9++23DZw8+Pn7We3AgQP67W9/q5EjRzZQ0qalrnUpLS3VmDFjdODAAb322mvatWuXFi5cqE6dOjVw8uBX19osWrRIM2bMUGpqqnbs2KEXXnhBS5Ys0R/+8IcGTh7c6trf2L9/v8aPH6/LLrtMWVlZmj59uqZOnapVq1YFOGkFA34ZOnSokZSUVDXt9XqNjh07GrNnzzYxFaqTZCxbtszsGKhFbm6uIclYu3at2VFQizZt2hjPP/+82TFgGEZ+fr5x/vnnG2lpacYll1xiTJs2zexITV5qaqoRGxtrdgw0MXXd77zuuuuM8ePH15gXFxdn3HnnnQHN2dSc6+eBsrIyIywszHj55ZcDFbHJ8qc2ZWVlxsUXX2w8//zzxpQpU4yrr766AZI2LXWtyzPPPGN0797dKC0tbaiITVZda5OUlGRcfvnlNealpKQYw4cPD2jOpuxs+hv33Xef0b9//xrzJk2aZIwdOzaAyU5iBKMfSktLlZmZqYSEhKp5drtdCQkJ2rBhg4nJgMbh+PHjkqS2bduanATVeb1eLV68WIWFhYqPjzc7DiQlJSVp/PjxNd5vYL7du3erY8eO6t69u2688UZ9/fXXZkdCEPNnv3PDhg2n/d0YO3Ys+6n1qD4+DxQVFcnj8bA/VM/8rc1DDz2kyMhI3XbbbQ0Rs8nxpy7/+c9/FB8fr6SkJEVFRWnAgAF65JFH5PV6Gyp2k+BPbS6++GJlZmZWHUa9b98+rVixQldeeWWDZEbtzH7/D2mQrQSZI0eOyOv1Kioqqsb8qKgo7dy506RUQOPg8/k0ffp0DR8+XAMGDDA7DiRt2bJF8fHxKi4uVsuWLbVs2TL169fP7FhN3uLFi/XZZ59p06ZNZkdBNXFxcXrppZfUu3dvHTp0SLNmzdLIkSO1detWhYWFmR0PQcif/c7s7Oxal8/Ozg5YzqamPj4P/P73v1fHjh35Eqme+VObdevW6YUXXlBWVlYDJGya/KnLvn379P777+vGG2/UihUrtGfPHt1zzz3yeDxKTU1tiNhNgj+1ueGGG3TkyBGNGDFChmGorKxMd911F4dIm+xM7/95eXk6ceKEmjVrFtDt02AE0KCSkpK0detWzllmIb1791ZWVpaOHz+u1157TVOmTNHatWtpMpro4MGDmjZtmtLS0hQaGmp2HFQzbty4qp8HDhyouLg4de3aVUuXLmXUC4CzNmfOHC1evFhr1qzh77zJ8vPzNXnyZC1cuFARERFmx0E1Pp9PkZGReu655+RwODRkyBB9++23evTRR2kwmmzNmjV65JFH9PTTTysuLk579uzRtGnT9PDDD+v+++83Ox5MQoPRDxEREXI4HMrJyakxPycnR9HR0SalAqwvOTlZy5cvV0ZGhjp37mx2HFRwuVzq2bOnJGnIkCHatGmTnnjiCT377LMmJ2u6MjMzlZubqwsvvLBqntfrVUZGhp566imVlJTI4XCYmBCVWrdurV69emnPnj1mR0GQ8me/Mzo6mv3UADuXzwOPPfaY5syZo/fee48LeAVAXWuzd+9eHThwQBMmTKia5/P5JEkhISHatWuXevToEdjQTYA/r5kOHTrI6XTW2Ofp27evsrOzVVpaKpfLFdDMTYU/tbn//vs1efJkTZ06VZJ0wQUXqLCwUHfccYf++Mc/ym7nbHxmONP7f3h4eMBHL0pcRdovLpdLQ4YMUXp6etU8n8+n9PR0zlsG1MIwDCUnJ2vZsmV6//331a1bN7Mj4Uf4fD6VlJSYHaNJGz16tLZs2aKsrKyq20UXXaQbb7xRWVlZNBctpKCgQHv37lWHDh3MjoIg5c9+Z3x8fI3lJSktLY391Hrk7+eBv/3tb3r44Ye1cuVKXXTRRQ0Rtcmpa2369Olz2nvuz3/+86qrsMbExDRk/KDlz2tm+PDh2rNnT1XDV5K+/PJLdejQgeZiPfKnNkVFRac1ESv3Tw3DCFxY/CjT3/8b5FIyQWjx4sWG2+02XnrpJWP79u3GHXfcYbRu3drIzs42O1qTlp+fb2zevNnYvHmzIcmYO3eusXnzZuOrr74yO1qTdvfddxutWrUy1qxZYxw6dKjqVlRUZHa0Jm/GjBnG2rVrjf379xtffPGFMWPGDMNmsxmrV682OxpOwVWkreE3v/mNsWbNGmP//v3G+vXrjYSEBCMiIsLIzc01OxqC2E/td06ePNmYMWNG1fLr1683QkJCjMcee8zYsWOHkZqaajidTmPLli1mPYWgVNe6zJkzx3C5XMZrr71WY38oPz/frKcQtOpam1NxFenAqGtdvv76ayMsLMxITk42du3aZSxfvtyIjIw0/vznP5v1FIJWXWuTmppqhIWFGa+88oqxb98+Y/Xq1UaPHj2M6667zqynEJR+qr8xY8YMY/LkyVXL79u3z2jevLnxu9/9ztixY4cxf/58w+FwGCtXrmyQvDQYz8GTTz5pdOnSxXC5XMbQoUONjz/+2OxITd4HH3xgSDrtNmXKFLOjNWm11USS8c9//tPsaE3erbfeanTt2tVwuVxG+/btjdGjR9NctCgajNYwadIko0OHDobL5TI6depkTJo0ydizZ4/ZsdAE/Nh+5yWXXHLavs7SpUuNXr16GS6Xy+jfv7/xzjvvNHDipqEudenatWut+0OpqakNH7wJqOtrpjoajIFT17p89NFHRlxcnOF2u43u3bsbf/nLX4yysrIGTt001KU2Ho/HePDBB40ePXoYoaGhRkxMjHHPPfcYP/zwQ8MHD2I/1d+YMmWKcckll5z2O4MGDTJcLpfRvXv3Bv3MbTMMxq8CAAAAAAAA8A/nYAQAAAAAAADgNxqMAAAAAAAAAPxGgxEAAAAAAACA32gwAgAAAAAAAPAbDUYAAAAAAAAAfqPBCAAAAAAAAMBvNBgBAAAAAAAA+I0GIwAAAAAAAAC/0WAEAAAAAAAA4DcajAAAAAAAAAD8RoMRAAAAAAAAgN9oMAIAAAAAAADw2/8DrXKDOHtN6XAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████| 5001/5001 [00:29<00:00, 170.14it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent_qr_dqn(env, agent, target_network, optimizer, td_loss_fn=loss_qr_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 977\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate_qr_dqn(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score: {:.0f}'.format(final_score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                     \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_f/QRDQN-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We also saw 2nd variant of distributional RL called **Distributional RL - Quantile Regression DQN (QR-DQN)**\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
